diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..af329c2
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    labels:
+      - 'maintenance'
+    groups:
+      actions:
+        patterns:
+          - '*'
diff --git a/.github/workflows/deploy-wasm.yml b/.github/workflows/deploy-wasm.yml
new file mode 100644
index 0000000..53df9d4
--- /dev/null
+++ b/.github/workflows/deploy-wasm.yml
@@ -0,0 +1,58 @@
+# Deploy WebAssembly cockle and terminal builds to github pages
+name: Deploy wasm to github pages
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+
+      - name: Install mamba
+        uses: mamba-org/setup-micromamba@v2
+        with:
+          environment-file: wasm/wasm-environment.yml
+          cache-environment: true
+
+      - name: Build the cockle and JupyterLite terminal deployments
+        shell: bash -l {0}
+        working-directory: wasm
+        run: |
+          cmake .
+          make
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./wasm/serve
+
+  deploy:
+    needs: build
+    permissions:
+      pages: write
+      id-token: write
+
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 8fe0ce6..6bd1a6c 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
diff --git a/.gitignore b/.gitignore
index e4f7ae8..9e99726 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@ build/
 __pycache__/
 .cache/
 compile_commands.json
+serve.log
diff --git a/.nojekyll b/.nojekyll
new file mode 100644
index 0000000..e69de29
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d18cbd9..36b401b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -50,14 +50,24 @@ set(GIT2CPP_SRC
     ${GIT2CPP_SOURCE_DIR}/subcommand/clone_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/commit_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/commit_subcommand.hpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/fetch_subcommand.cpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/fetch_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/init_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/init_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/log_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/log_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/merge_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/merge_subcommand.hpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/push_subcommand.cpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/push_subcommand.hpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/remote_subcommand.cpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/remote_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/reset_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/reset_subcommand.hpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/revlist_subcommand.cpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/revlist_subcommand.hpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/revparse_subcommand.cpp
+    ${GIT2CPP_SOURCE_DIR}/subcommand/revparse_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/status_subcommand.cpp
     ${GIT2CPP_SOURCE_DIR}/subcommand/status_subcommand.hpp
     ${GIT2CPP_SOURCE_DIR}/utils/ansi_code.cpp
@@ -68,6 +78,8 @@ set(GIT2CPP_SRC
     ${GIT2CPP_SOURCE_DIR}/utils/git_exception.hpp
     ${GIT2CPP_SOURCE_DIR}/utils/output.cpp
     ${GIT2CPP_SOURCE_DIR}/utils/output.hpp
+    ${GIT2CPP_SOURCE_DIR}/utils/progress.cpp
+    ${GIT2CPP_SOURCE_DIR}/utils/progress.hpp
     ${GIT2CPP_SOURCE_DIR}/utils/terminal_pager.cpp
     ${GIT2CPP_SOURCE_DIR}/utils/terminal_pager.hpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/annotated_commit_wrapper.cpp
@@ -82,8 +94,12 @@ set(GIT2CPP_SRC
     ${GIT2CPP_SOURCE_DIR}/wrapper/object_wrapper.hpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/refs_wrapper.cpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/refs_wrapper.hpp
+    ${GIT2CPP_SOURCE_DIR}/wrapper/remote_wrapper.cpp
+    ${GIT2CPP_SOURCE_DIR}/wrapper/remote_wrapper.hpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/repository_wrapper.cpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/repository_wrapper.hpp
+    ${GIT2CPP_SOURCE_DIR}/wrapper/revwalk_wrapper.cpp
+    ${GIT2CPP_SOURCE_DIR}/wrapper/revwalk_wrapper.hpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/signature_wrapper.cpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/signature_wrapper.hpp
     ${GIT2CPP_SOURCE_DIR}/wrapper/status_wrapper.cpp
diff --git a/README.md b/README.md
index 64c6743..b9cc19f 100644
--- a/README.md
+++ b/README.md
@@ -25,3 +25,16 @@ The CLI is tested using `python`. From the top-level directory:
 ```bash
 pytest -v
 ```
+
+# WebAssembly build and deployment
+
+The `wasm` directory contains everything needed to build the local `git2cpp` source code as an
+WebAssembly [Emscripten-forge](https://emscripten-forge.org/) package, create local
+[cockle](https://github.com/jupyterlite/cockle) and
+[JupyterLite terminal](https://github.com/jupyterlite/terminal) deployments that run in a browser,
+and test the WebAssembly build.
+
+See the `README.md` in the `wasm` directory for further details.
+
+The latest `cockle` and JupyterLite `terminal` deployments using `git2cpp` are available at
+[https://quantstack.net/git2cpp](https://quantstack.net/git2cpp)
diff --git a/src/main.cpp b/src/main.cpp
index e8479c8..9a3012b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -10,11 +10,16 @@
 #include "subcommand/checkout_subcommand.hpp"
 #include "subcommand/clone_subcommand.hpp"
 #include "subcommand/commit_subcommand.hpp"
+#include "subcommand/fetch_subcommand.hpp"
 #include "subcommand/init_subcommand.hpp"
 #include "subcommand/log_subcommand.hpp"
 #include "subcommand/merge_subcommand.hpp"
+#include "subcommand/push_subcommand.hpp"
+#include "subcommand/remote_subcommand.hpp"
 #include "subcommand/reset_subcommand.hpp"
 #include "subcommand/status_subcommand.hpp"
+#include "subcommand/revparse_subcommand.hpp"
+#include "subcommand/revlist_subcommand.hpp"
 
 int main(int argc, char** argv)
 {
@@ -35,9 +40,14 @@ int main(int argc, char** argv)
         checkout_subcommand checkout(lg2_obj, app);
         clone_subcommand clone(lg2_obj, app);
         commit_subcommand commit(lg2_obj, app);
+        fetch_subcommand fetch(lg2_obj, app);
         reset_subcommand reset(lg2_obj, app);
         log_subcommand log(lg2_obj, app);
         merge_subcommand merge(lg2_obj, app);
+        push_subcommand push(lg2_obj, app);
+        remote_subcommand remote(lg2_obj, app);
+        revparse_subcommand revparse(lg2_obj, app);
+        revlist_subcommand revlist(lg2_obj, app);
 
         app.require_subcommand(/* min */ 0, /* max */ 1);
 
diff --git a/src/subcommand/branch_subcommand.cpp b/src/subcommand/branch_subcommand.cpp
index c321fa8..82decf1 100644
--- a/src/subcommand/branch_subcommand.cpp
+++ b/src/subcommand/branch_subcommand.cpp
@@ -39,7 +39,7 @@ void branch_subcommand::run()
 
 void branch_subcommand::run_list(const repository_wrapper& repo)
 {
-    auto head_name = repo.head().short_name();
+    auto head_name = repo.head_short_name();
     git_branch_t type = m_all_flag ? GIT_BRANCH_ALL : (m_remote_flag ? GIT_BRANCH_REMOTE : GIT_BRANCH_LOCAL);
     auto iter = repo.iterate_branches(type);
     auto br = iter.next();
diff --git a/src/subcommand/clone_subcommand.cpp b/src/subcommand/clone_subcommand.cpp
index 6c9b803..acc6f14 100644
--- a/src/subcommand/clone_subcommand.cpp
+++ b/src/subcommand/clone_subcommand.cpp
@@ -2,6 +2,7 @@
 
 #include "../subcommand/clone_subcommand.hpp"
 #include "../utils/output.hpp"
+#include "../utils/progress.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 clone_subcommand::clone_subcommand(const libgit2_object&, CLI::App& app)
@@ -10,83 +11,30 @@ 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_flag("--bare", m_bare, "Create a bare Git repository.");
 
     sub->callback([this]() { this->run(); });
 }
 
-namespace
+void clone_subcommand::run()
 {
-    int sideband_progress(const char* str, int len, void*)
-    {
-        printf("remote: %.*s", len, str);
-        fflush(stdout);
-        return 0;
-    }
-
-    int fetch_progress(const git_indexer_progress* stats, void* payload)
+    // 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)
     {
-        static bool done = false;
-
-        // We need to copy stats into payload even if the fetch is done,
-        // because the checkout_progress callback will be called with the
-        // same payload and needs the data to be up do date.
-        auto* pr = reinterpret_cast<git_indexer_progress*>(payload);
-        *pr = *stats;
-
-        if (done)
-        {
-            return 0;
-        }
-        
-        int network_percent = pr->total_objects > 0 ?
-            (100 * pr->received_objects / pr->total_objects)
-            : 0;
-        size_t mbytes = pr->received_bytes / (1024*1024);
-
-        std::cout << "Receiving objects: " << std::setw(4) << network_percent
-            << "% (" << pr->received_objects << "/" << pr->total_objects << "), "
-            << mbytes << " MiB";
-
-        if (pr->received_objects == pr->total_objects)
-        {
-            std::cout << ", done." << std::endl;
-            done = true;
-        }
-        else
-        {
-            std::cout << '\r';
-        }
-        return 0;
+        std::cout << "fatal: depth 0 is not a positive number" << std::endl;
+        return;
     }
 
-    void checkout_progress(const char* path, size_t cur, size_t tot, void* payload)
+    if (m_depth == std::numeric_limits<size_t>::max())
     {
-        static bool done = false;
-        if (done)
-        {
-            return;
-        }
-        auto* pr = reinterpret_cast<git_indexer_progress*>(payload);
-        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 << ")";
-        if (pr->indexed_deltas == pr->total_deltas)
-        {
-            std::cout << ", done." << std::endl;
-            done = true;
-        }
-        else
-        {
-            std::cout << '\r';
-        }
+        m_depth = 0;
     }
-}
 
-void clone_subcommand::run()
-{
     git_indexer_progress pd;
     git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
     git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
@@ -94,9 +42,11 @@ void clone_subcommand::run()
     checkout_opts.progress_cb = checkout_progress;
     checkout_opts.progress_payload = &pd;
     clone_opts.checkout_opts = checkout_opts;
-	  clone_opts.fetch_opts.callbacks.sideband_progress = sideband_progress;
-	  clone_opts.fetch_opts.callbacks.transfer_progress = fetch_progress;
-	  clone_opts.fetch_opts.callbacks.payload = &pd;
+    clone_opts.fetch_opts.callbacks.sideband_progress = sideband_progress;
+    clone_opts.fetch_opts.callbacks.transfer_progress = fetch_progress;
+    clone_opts.fetch_opts.callbacks.payload = &pd;
+    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 bf2a0d7..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"
 
@@ -15,4 +16,8 @@ class clone_subcommand
 
     std::string m_repository = {};
     std::string m_directory = {};
+    bool m_bare = false;
+    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
new file mode 100644
index 0000000..0662970
--- /dev/null
+++ b/src/subcommand/fetch_subcommand.cpp
@@ -0,0 +1,82 @@
+#include <iostream>
+
+#include <git2/remote.h>
+
+#include "../subcommand/fetch_subcommand.hpp"
+#include "../utils/output.hpp"
+#include "../utils/progress.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
+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("--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_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(); });
+}
+
+void fetch_subcommand::run()
+{
+    auto directory = get_current_git_path();
+    auto repo = repository_wrapper::open(directory);
+
+    // Find the remote (default to origin if not specified)
+    std::string remote_name = m_remote_name.empty() ? "origin" : m_remote_name;
+    auto remote = repo.find_remote(remote_name);
+
+    git_indexer_progress pd = {0};
+    git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+    fetch_opts.callbacks.sideband_progress = sideband_progress;
+    fetch_opts.callbacks.transfer_progress = fetch_progress;
+    fetch_opts.callbacks.payload = &pd;
+    fetch_opts.callbacks.update_refs = update_refs;
+
+    if (repo.is_shallow())
+    {
+        if (m_unshallow)
+        {
+            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;
+        }
+    }
+    else
+    {
+        fetch_opts.depth = 0;
+    }
+
+
+    cursor_hider ch;
+
+    // Perform the fetch
+    remote.fetch(nullptr, &fetch_opts, "fetch");
+
+    // Show statistics
+    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;
+    }
+    else
+    {
+        std::cout << "\rReceived " << stats->indexed_objects << "/" << stats->total_objects
+            << " objects in " << stats->received_bytes << " bytes" << std::endl;
+    }
+}
diff --git a/src/subcommand/fetch_subcommand.hpp b/src/subcommand/fetch_subcommand.hpp
new file mode 100644
index 0000000..41bc069
--- /dev/null
+++ b/src/subcommand/fetch_subcommand.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstddef>
+#include <string>
+
+#include <CLI/CLI.hpp>
+
+#include "../utils/common.hpp"
+
+class fetch_subcommand
+{
+public:
+
+    explicit fetch_subcommand(const libgit2_object&, CLI::App& app);
+    void run();
+
+    std::string m_remote_name;
+    size_t m_depth = 0;
+    size_t m_deepen = 0;
+    // std::string m_shallow_since;
+    // std::string m_shallow_exclude;
+    bool m_unshallow = false;
+    // bool m_update_shallow = false;
+};
diff --git a/src/subcommand/log_subcommand.cpp b/src/subcommand/log_subcommand.cpp
index c295c7f..856ba7d 100644
--- a/src/subcommand/log_subcommand.cpp
+++ b/src/subcommand/log_subcommand.cpp
@@ -87,22 +87,25 @@ void log_subcommand::run()
     auto repo = repository_wrapper::open(directory);
     // auto branch_name = repo.head().short_name();
 
-    git_revwalk* walker;
-    git_revwalk_new(&walker, repo);
-    git_revwalk_push_head(walker);
+    if (repo.is_head_unborn())
+    {
+        std::cout << "fatal: your current branch 'main' does not have any commits yet" << std::endl;
+        return;
+    }
+
+    revwalk_wrapper walker = repo.new_walker();
+    walker.push_head();
 
     terminal_pager pager;
 
     std::size_t i=0;
     git_oid commit_oid;
-    while (!git_revwalk_next(&commit_oid, walker) && i<m_max_count_flag)
+    while (!walker.next(commit_oid) && i<m_max_count_flag)
     {
         commit_wrapper commit = repo.find_commit(commit_oid);
         print_commit(commit, m_format_flag);
         ++i;
     }
 
-    git_revwalk_free(walker);
-
     pager.show();
 }
diff --git a/src/subcommand/push_subcommand.cpp b/src/subcommand/push_subcommand.cpp
new file mode 100644
index 0000000..be04267
--- /dev/null
+++ b/src/subcommand/push_subcommand.cpp
@@ -0,0 +1,54 @@
+#include <iostream>
+
+#include <git2/remote.h>
+
+#include "../subcommand/push_subcommand.hpp"
+#include "../utils/progress.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
+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("<refspec>", m_refspecs, "The refspec(s) to push");
+
+    sub->callback([this]() { this->run(); });
+}
+
+void push_subcommand::run()
+{
+    auto directory = get_current_git_path();
+    auto repo = repository_wrapper::open(directory);
+
+    std::string remote_name = m_remote_name.empty() ? "origin" : m_remote_name;
+    auto remote = repo.find_remote(remote_name);
+
+    git_push_options push_opts = GIT_PUSH_OPTIONS_INIT;
+    push_opts.callbacks.push_transfer_progress = push_transfer_progress;
+    push_opts.callbacks.push_update_reference = push_update_reference;
+
+    if (m_refspecs.empty())
+    {
+        try
+        {
+            auto head_ref = repo.head();
+            std::string short_name = head_ref.short_name();
+            std::string refspec = "refs/heads/" + short_name;
+            m_refspecs.push_back(refspec);
+        }
+        catch (...)
+        {
+            std::cerr << "Could not determine current branch to push." << std::endl;
+            return;
+        }
+    }
+    git_strarray_wrapper refspecs_wrapper(m_refspecs);
+    git_strarray* refspecs_ptr = nullptr;
+    refspecs_ptr = refspecs_wrapper;
+
+    remote.push(refspecs_ptr, &push_opts);
+    std::cout << "Pushed to " << remote_name << std::endl;
+}
diff --git a/src/subcommand/push_subcommand.hpp b/src/subcommand/push_subcommand.hpp
new file mode 100644
index 0000000..07c301e
--- /dev/null
+++ b/src/subcommand/push_subcommand.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <CLI/CLI.hpp>
+
+#include "../utils/common.hpp"
+
+class push_subcommand
+{
+public:
+
+    explicit push_subcommand(const libgit2_object&, CLI::App& app);
+    void run();
+
+private:
+
+    std::string m_remote_name;
+    std::vector<std::string> m_refspecs;
+};
diff --git a/src/subcommand/remote_subcommand.cpp b/src/subcommand/remote_subcommand.cpp
new file mode 100644
index 0000000..f76ad70
--- /dev/null
+++ b/src/subcommand/remote_subcommand.cpp
@@ -0,0 +1,194 @@
+#include <iostream>
+#include <stdexcept>
+
+#include "../subcommand/remote_subcommand.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
+remote_subcommand::remote_subcommand(const libgit2_object&, CLI::App& app)
+{
+    m_subcommand = app.add_subcommand("remote", "Manage set of tracked repositories");
+
+    m_subcommand->add_option("operation", m_operation, "Operation: add, remove, rename, set-url, show")
+        ->check(CLI::IsMember({"add", "remove", "rm", "rename", "set-url", "show"}));
+
+    m_subcommand->add_flag("-v,--verbose", m_verbose_flag, "Be verbose");
+    m_subcommand->add_flag("--push", m_push_flag, "Set push URL instead of fetch URL");
+
+    // Allow positional arguments after operation
+    m_subcommand->allow_extras();
+
+    m_subcommand->callback([this]() { this->run(); });
+}
+
+void remote_subcommand::run()
+{
+    auto directory = get_current_git_path();
+    auto repo = repository_wrapper::open(directory);
+
+    // Get extra positional arguments
+    auto extras = m_subcommand->remaining();
+
+    // Parse positional arguments based on operation
+    if (m_operation == "add")
+    {
+        if (extras.size() == 2)
+        {
+            m_remote_name = extras[0];
+            m_url = extras[1];
+        }
+        run_add(repo);
+    }
+    else if (m_operation == "remove" || m_operation == "rm")
+    {
+        if (extras.size() == 1)
+        {
+            m_remote_name = extras[0];
+        }
+        run_remove(repo);
+    }
+    else if (m_operation == "rename")
+    {
+        if (extras.size() == 2)
+        {
+            m_old_name = extras[0];
+            m_new_name = extras[1];
+        }
+        run_rename(repo);
+    }
+    else if (m_operation == "set-url")
+    {
+        // Handle --push flag before arguments
+        size_t arg_idx = 0;
+        if (extras.size() > 0 && extras[0] == "--push")
+        {
+            m_push_flag = true;
+            arg_idx = 1;
+        }
+        if (extras.size() >= arg_idx + 2)
+        {
+            m_remote_name = extras[arg_idx];
+            m_new_name = extras[arg_idx + 1];
+            run_seturl(repo);
+        }
+        else if (m_remote_name.empty() || m_new_name.empty())
+        {
+            throw std::runtime_error("remote set-url requires both name and new URL");
+        }
+        else
+        {
+            run_seturl(repo);
+        }
+    }
+    else if (m_operation.empty() || m_operation == "show")
+    {
+        if (extras.size() >= 1)
+        {
+            m_remote_name = extras[0];
+        }
+        run_show(repo);
+    }
+}
+
+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
+    }
+    repo.create_remote(m_remote_name, m_url);
+}
+
+void remote_subcommand::run_remove(repository_wrapper& repo)
+{
+    if (m_remote_name.empty())
+    {
+        throw std::runtime_error("usage: git remote remove <name>");
+    }
+    repo.delete_remote(m_remote_name);
+}
+
+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
+    }
+    repo.rename_remote(m_old_name, m_new_name);
+}
+
+void remote_subcommand::run_seturl(repository_wrapper& repo)
+{
+    if (m_remote_name.empty() || m_new_name.empty())
+    {
+        throw std::runtime_error("remote set-url requires both name and new URL");
+    }
+    repo.set_remote_url(m_remote_name, m_new_name, m_push_flag);
+}
+
+void remote_subcommand::run_show(const repository_wrapper& repo)
+{
+    auto remotes = repo.list_remotes();
+
+    if (m_remote_name.empty())
+    {
+        // Show all remotes
+        for (const auto& name : remotes)
+        {
+            if (m_verbose_flag)
+            {
+                auto remote = repo.find_remote(name);
+                auto fetch_url = remote.url();
+                auto push_url = remote.pushurl();
+
+                if (!fetch_url.empty())
+                {
+                    std::cout << name << "\t" << fetch_url << " (fetch)" << std::endl;
+                }
+                if (!push_url.empty())
+                {
+                    std::cout << name << "\t" << push_url << " (push)" << std::endl;
+                }
+                else if (!fetch_url.empty())
+                {
+                    std::cout << name << "\t" << fetch_url << " (push)" << std::endl;
+                }
+            }
+            else
+            {
+                std::cout << name << std::endl;
+            }
+        }
+    }
+    else
+    {
+        // Show specific remote
+        auto remote = repo.find_remote(m_remote_name);
+        std::cout << "* remote " << m_remote_name << std::endl;
+
+        auto fetch_url = remote.url();
+        if (!fetch_url.empty())
+        {
+            std::cout << "  Fetch URL: " << fetch_url << std::endl;
+        }
+
+        auto push_url = remote.pushurl();
+        if (!push_url.empty())
+        {
+            std::cout << "  Push  URL: " << push_url << std::endl;
+        }
+        else if (!fetch_url.empty())
+        {
+            std::cout << "  Push  URL: " << fetch_url << std::endl;
+        }
+
+        auto refspecs = remote.refspecs();
+        if (!refspecs.empty())
+        {
+            std::cout << "  HEAD branch: (not yet implemented)" << std::endl;
+            for (const auto& refspec : refspecs)
+            {
+                std::cout << "  " << refspec << std::endl;
+            }
+        }
+    }
+}
diff --git a/src/subcommand/remote_subcommand.hpp b/src/subcommand/remote_subcommand.hpp
new file mode 100644
index 0000000..b6f3bf2
--- /dev/null
+++ b/src/subcommand/remote_subcommand.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <string>
+
+#include <CLI/CLI.hpp>
+
+#include "../utils/common.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+
+class remote_subcommand
+{
+public:
+
+    explicit remote_subcommand(const libgit2_object&, CLI::App& app);
+    void run();
+
+private:
+
+    void run_list(const repository_wrapper& repo);
+    void run_add(repository_wrapper& repo);
+    void run_remove(repository_wrapper& repo);
+    void run_rename(repository_wrapper& repo);
+    void run_seturl(repository_wrapper& repo);
+    void run_show(const repository_wrapper& repo);
+
+    CLI::App* m_subcommand = nullptr;
+    std::string m_operation;
+    std::string m_remote_name;
+    std::string m_url;
+    std::string m_old_name;
+    std::string m_new_name;
+    bool m_verbose_flag = false;
+    bool m_push_flag = false;
+};
diff --git a/src/subcommand/revlist_subcommand.cpp b/src/subcommand/revlist_subcommand.cpp
new file mode 100644
index 0000000..fafa830
--- /dev/null
+++ b/src/subcommand/revlist_subcommand.cpp
@@ -0,0 +1,45 @@
+#include "revlist_subcommand.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+#include "../wrapper/revwalk_wrapper.hpp"
+
+revlist_subcommand::revlist_subcommand(const libgit2_object&, CLI::App& app)
+{
+    auto* sub = app.add_subcommand("rev-list", "Lists commit objects in reverse chronological order");
+
+    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(); });
+}
+
+void revlist_subcommand::run()
+{
+    if (m_commit.empty())
+    {
+        throw std::runtime_error("usage: git rev-list [<options>] <commit>... [--] [<path>...]");   // TODO: add  help info
+    }
+
+    auto directory = get_current_git_path();
+    auto repo = repository_wrapper::open(directory);
+    git_oid start_commit_oid;
+    int not_sha1 = git_oid_fromstrp(&start_commit_oid, m_commit.c_str());
+    if (not_sha1)
+    {
+        commit_wrapper start_commit = repo.find_commit(m_commit);
+        start_commit_oid = start_commit.oid();
+    }
+
+    revwalk_wrapper walker = repo.new_walker();
+    walker.push(start_commit_oid);
+
+    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)
+    {
+        git_oid_fmt(buf, &commit_oid);
+		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
new file mode 100644
index 0000000..977f20d
--- /dev/null
+++ b/src/subcommand/revlist_subcommand.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <CLI/CLI.hpp>
+#include <string>
+
+#include "../utils/common.hpp"
+
+class revlist_subcommand
+{
+public:
+
+    explicit revlist_subcommand(const libgit2_object&, CLI::App& app);
+    void run();
+
+private:
+
+    std::string m_commit;
+    int m_max_count_flag=std::numeric_limits<int>::max();
+
+};
diff --git a/src/subcommand/revparse_subcommand.cpp b/src/subcommand/revparse_subcommand.cpp
new file mode 100644
index 0000000..a521ad6
--- /dev/null
+++ b/src/subcommand/revparse_subcommand.cpp
@@ -0,0 +1,33 @@
+#include "revparse_subcommand.hpp"
+#include "../wrapper/repository_wrapper.hpp"
+#include <ios>
+#include <stdexcept>
+
+revparse_subcommand::revparse_subcommand(const libgit2_object&, CLI::App& app)
+{
+    auto* sub = app.add_subcommand("rev-parse", "Pick out and message parameters");
+
+    sub->add_flag("--is-bare-repository", m_is_bare_repository_flag);
+    sub->add_flag("--is-shallow-repository", m_is_shallow_repository_flag);
+
+    sub->callback([this]() { this->run(); });
+}
+
+void revparse_subcommand::run()
+{
+    auto directory = get_current_git_path();
+    auto repo = repository_wrapper::open(directory);
+
+    if (m_is_bare_repository_flag)
+    {
+        std::cout << std::boolalpha << repo.is_bare() << std::endl;
+    }
+    else if (m_is_shallow_repository_flag)
+    {
+        std::cout << std::boolalpha << repo.is_shallow() << std::endl;
+    }
+    else
+    {
+        std::cout << "revparse only supports --is-bare-repository and --is-shallow-repository for now" << std::endl;
+    }
+}
diff --git a/src/subcommand/revparse_subcommand.hpp b/src/subcommand/revparse_subcommand.hpp
new file mode 100644
index 0000000..dcc363a
--- /dev/null
+++ b/src/subcommand/revparse_subcommand.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <CLI/CLI.hpp>
+
+#include "../utils/common.hpp"
+
+class revparse_subcommand
+{
+public:
+
+    explicit revparse_subcommand(const libgit2_object&, CLI::App& app);
+    void run();
+
+private:
+
+    bool m_is_bare_repository_flag = false;
+    bool m_is_shallow_repository_flag = false;
+};
diff --git a/src/subcommand/status_subcommand.cpp b/src/subcommand/status_subcommand.cpp
index 36aa213..02acbd6 100644
--- a/src/subcommand/status_subcommand.cpp
+++ b/src/subcommand/status_subcommand.cpp
@@ -167,7 +167,7 @@ void status_subcommand::run()
     auto directory = get_current_git_path();
     auto repo = repository_wrapper::open(directory);
     auto sl = status_list_wrapper::status_list(repo);
-    auto branch_name = repo.head().short_name();
+    auto branch_name = repo.head_short_name();
 
     std::set<std::string> tracked_dir_set{};
     std::set<std::string> untracked_dir_set{};
@@ -194,6 +194,11 @@ void status_subcommand::run()
     {
         std::cout  << "On branch " << branch_name << "\n" << std::endl;
 
+        if (repo.is_head_unborn())
+        {
+            std::cout << "No commits yet\n" << std::endl;
+        }
+
         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;
@@ -274,20 +279,9 @@ void status_subcommand::run()
     // TODO: check if this message should be displayed even if there are untracked files
     if (!(sl.has_tobecommited_header() | sl.has_notstagged_header() | sl.has_unmerged_header() | sl.has_untracked_header()))
     {
-        std::cout << treeclean_message << std::endl;
+        if (is_long)
+        {
+            std::cout << treeclean_message << std::endl;
+        }
     }
-
-    // if (sl.has_ignored_header())
-    // {
-    //     stream_colour_fn colour = termcolor::red;
-    //     if (is_long)
-    //     {
-    //         std::cout << ignored_header;
-    //     }
-    //     print_not_tracked(get_entries_to_print(GIT_STATUS_IGNORED, sl, false, of), tracked_dir_set, untracked_dir_set, is_long, colour);
-    //     if (is_long)
-    //     {
-    //         std::cout << std::endl;
-    //     }
-    // }
 }
diff --git a/src/utils/progress.cpp b/src/utils/progress.cpp
new file mode 100644
index 0000000..bdb3a23
--- /dev/null
+++ b/src/utils/progress.cpp
@@ -0,0 +1,155 @@
+#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);
+    fflush(stdout);
+    return 0;
+}
+
+int fetch_progress(const git_indexer_progress* stats, void* payload)
+{
+    static bool done = false;
+
+    // We need to copy stats into payload even if the fetch is done,
+    // because the checkout_progress callback will be called with the
+    // same payload and needs the data to be up do date.
+    auto* pr = reinterpret_cast<git_indexer_progress*>(payload);
+    *pr = *stats;
+
+    if (done)
+    {
+        return 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 << "), ";
+    if (mbytes != 0)
+    {
+        std::cout << mbytes << " MiB";
+    }
+    else if  (kbytes != 0)
+    {
+        std::cout << kbytes << " KiB";
+    }
+    else
+    {
+        std::cout << pr->received_bytes << " bytes";
+    }
+    // TODO: compute speed
+
+    if (pr->received_objects == pr->total_objects)
+    {
+        std::cout << ", done." << std::endl;
+        done = true;
+    }
+    else
+    {
+        std::cout << '\r';
+    }
+    return 0;
+}
+
+void checkout_progress(const char* path, size_t cur, size_t tot, void* payload)
+{
+    static bool done = false;
+    if (done)
+    {
+        return;
+    }
+    auto* pr = reinterpret_cast<git_indexer_progress*>(payload);
+    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 << ")";
+    if (pr->indexed_deltas == pr->total_deltas)
+    {
+        std::cout << ", done." << std::endl;
+        done = true;
+    }
+    else
+    {
+        std::cout << '\r';
+    }
+}
+
+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];
+
+    git_oid_fmt(b_str, b);
+    b_str[GIT_OID_SHA1_HEXSIZE] = '\0';
+
+    if (git_oid_is_zero(a))
+    {
+        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
+        {
+            n = " * [new branch]      ";
+            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);
+        }
+        else if (std::string_view(refname).find("tags") != std::string::npos)
+        {
+            n = " * [new tag]         ";
+            ref = name;
+        }
+        else
+        {
+            // could it be something else ?
+        }
+        std::cout << n << name << "\t-> " << ref << std::endl;
+    }
+    else
+    {
+        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;
+    }
+
+    return 0;
+}
+
+int push_transfer_progress(unsigned int current, unsigned int total, size_t bytes, void*)
+{
+    if (total > 0)
+    {
+        int percent = (100 * current) / total;
+        std::cout << "Writing objects: " << percent << "% (" << current
+            << "/" << total << "), " << bytes << " bytes\r";
+    }
+    return 0;
+}
+
+int push_update_reference(const char* refname, const char* status, void*)
+{
+    if (status)
+    {
+        std::cout << "  " << refname << " " << status << std::endl;
+    }
+    else
+    {
+        std::cout << "  " << refname << std::endl;
+    }
+    return 0;
+}
diff --git a/src/utils/progress.hpp b/src/utils/progress.hpp
new file mode 100644
index 0000000..861c8d9
--- /dev/null
+++ b/src/utils/progress.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <git2.h>
+
+int sideband_progress(const char* str, int len, void*);
+int fetch_progress(const git_indexer_progress* stats, void* payload);
+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*);
+int push_transfer_progress(unsigned int current, unsigned int total, size_t bytes, void*);
+int push_update_reference(const char* refname, const char* status, void*);
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/remote_wrapper.cpp b/src/wrapper/remote_wrapper.cpp
new file mode 100644
index 0000000..08420ca
--- /dev/null
+++ b/src/wrapper/remote_wrapper.cpp
@@ -0,0 +1,63 @@
+#include <vector>
+#include <string>
+
+#include <git2/remote.h>
+
+#include "../utils/git_exception.hpp"
+#include "../wrapper/remote_wrapper.hpp"
+
+remote_wrapper::remote_wrapper(git_remote* remote)
+    : base_type(remote)
+{
+}
+
+remote_wrapper::~remote_wrapper()
+{
+    git_remote_free(p_resource);
+    p_resource = nullptr;
+}
+
+std::string_view remote_wrapper::name() const
+{
+    const char* out = git_remote_name(*this);
+    return out ? std::string_view(out) : std::string_view();
+}
+
+std::string_view remote_wrapper::url() const
+{
+    const char* out = git_remote_url(*this);
+    return out ? std::string_view(out) : std::string_view();
+}
+
+std::string_view remote_wrapper::pushurl() const
+{
+    const char* out = git_remote_pushurl(*this);
+    return out ? std::string_view(out) : std::string_view();
+}
+
+std::vector<std::string> remote_wrapper::refspecs() const
+{
+    git_strarray refspecs = {0};
+    std::vector<std::string> result;
+
+    if (git_remote_get_fetch_refspecs(&refspecs, *this) == 0)
+    {
+        for (size_t i = 0; i < refspecs.count; ++i)
+        {
+            result.emplace_back(refspecs.strings[i]);
+        }
+        git_strarray_dispose(&refspecs);
+    }
+
+    return result;
+}
+
+void remote_wrapper::fetch(const git_strarray* refspecs, const git_fetch_options* opts, const char* reflog_message)
+{
+    throw_if_error(git_remote_fetch(*this, refspecs, opts, reflog_message));
+}
+
+void remote_wrapper::push(const git_strarray* refspecs, const git_push_options* opts)
+{
+    throw_if_error(git_remote_push(*this, refspecs, opts));
+}
diff --git a/src/wrapper/remote_wrapper.hpp b/src/wrapper/remote_wrapper.hpp
new file mode 100644
index 0000000..1fa1632
--- /dev/null
+++ b/src/wrapper/remote_wrapper.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <git2/remote.h>
+#include <string_view>
+#include <vector>
+
+#include <git2.h>
+
+#include "../wrapper/wrapper_base.hpp"
+
+class remote_wrapper : public wrapper_base<git_remote>
+{
+public:
+
+    using base_type = wrapper_base<git_remote>;
+
+    ~remote_wrapper();
+
+    remote_wrapper(remote_wrapper&&) = default;
+    remote_wrapper& operator=(remote_wrapper&&) = default;
+
+    std::string_view name() const;
+    std::string_view url() const;
+    std::string_view pushurl() const;
+
+    std::vector<std::string> refspecs() const;
+
+    void fetch(const git_strarray* refspecs, const git_fetch_options* opts, const char* reflog_message);
+    void push(const git_strarray* refspecs, const git_push_options* opts);
+
+private:
+
+    explicit remote_wrapper(git_remote* remote);
+
+    friend class repository_wrapper;
+};
diff --git a/src/wrapper/repository_wrapper.cpp b/src/wrapper/repository_wrapper.cpp
index fcbd365..e7b2413 100644
--- a/src/wrapper/repository_wrapper.cpp
+++ b/src/wrapper/repository_wrapper.cpp
@@ -1,8 +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 <git2/repository.h>
+#include "../wrapper/remote_wrapper.hpp"
 #include "../wrapper/repository_wrapper.hpp"
 
 repository_wrapper::~repository_wrapper()
@@ -32,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));
@@ -42,7 +51,29 @@ void repository_wrapper::state_cleanup()
     throw_if_error(git_repository_state_cleanup(*this));
 }
 
-// References
+bool repository_wrapper::is_bare() const
+{
+    return git_repository_is_bare(*this);
+}
+
+bool repository_wrapper::is_shallow() const
+{
+    return git_repository_is_shallow(*this);
+}
+
+revwalk_wrapper repository_wrapper::new_walker()
+{
+    git_revwalk* walker;
+    throw_if_error(git_revwalk_new(&walker, *this));
+    return revwalk_wrapper(walker);
+}
+
+// Head
+
+bool repository_wrapper::is_head_unborn() const
+{
+    return git_repository_head_unborn(*this) == 1;
+}
 
 reference_wrapper repository_wrapper::head() const
 {
@@ -51,6 +82,26 @@ reference_wrapper repository_wrapper::head() const
     return reference_wrapper(ref);
 }
 
+std::string repository_wrapper::head_short_name() const
+{
+    git_reference* ref;
+    std::string name;
+    throw_if_error(git_reference_lookup(&ref, *this, "HEAD"));
+    if (git_reference_type(ref) == GIT_REFERENCE_DIRECT)
+    {
+         name = git_reference_shorthand(ref);
+    }
+    else
+    {
+        name = git_reference_symbolic_target(ref);
+        name = name.substr(name.find_last_of('/') + 1);
+    }
+    git_reference_free(ref);
+    return name;
+}
+
+// References
+
 reference_wrapper repository_wrapper::find_reference(std::string_view ref_name) const
 {
     git_reference* ref;
@@ -232,9 +283,146 @@ 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)
 {
     throw_if_error(git_checkout_tree(*this, target, &opts));
 }
+
+// Remotes
+
+remote_wrapper repository_wrapper::find_remote(std::string_view name) const
+{
+    git_remote* remote = nullptr;
+    throw_if_error(git_remote_lookup(&remote, *this, name.data()));
+    return remote_wrapper(remote);
+}
+
+remote_wrapper repository_wrapper::create_remote(std::string_view name, std::string_view url)
+{
+    git_remote* remote = nullptr;
+    throw_if_error(git_remote_create(&remote, *this, name.data(), url.data()));
+    return remote_wrapper(remote);
+}
+
+void repository_wrapper::delete_remote(std::string_view name)
+{
+    throw_if_error(git_remote_delete(*this, name.data()));
+}
+
+void repository_wrapper::rename_remote(std::string_view old_name, std::string_view new_name)
+{
+    git_strarray problems = {0};
+    int error = git_remote_rename(&problems, *this, old_name.data(), new_name.data());
+    if (error != 0)
+    {
+        for (size_t i = 0; i < problems.count; ++i)
+        {
+            std::cerr << problems.strings[i] << std::endl;
+        }
+        git_strarray_dispose(&problems);
+        throw_if_error(error);
+    }
+    git_strarray_dispose(&problems);
+}
+
+void repository_wrapper::set_remote_url(std::string_view name, std::string_view url, bool push)
+{
+    if (push)
+    {
+        throw_if_error(git_remote_set_pushurl(*this, name.data(), url.data()));
+    }
+    else
+    {
+        throw_if_error(git_remote_set_url(*this, name.data(), url.data()));
+    }
+}
+
+std::vector<std::string> repository_wrapper::list_remotes() const
+{
+    git_strarray remotes = {0};
+    throw_if_error(git_remote_list(&remotes, *this));
+
+    std::vector<std::string> result;
+    for (size_t i = 0; i < remotes.count; ++i)
+    {
+        result.emplace_back(remotes.strings[i]);
+    }
+
+    git_strarray_dispose(&remotes);
+    return result;
+}
diff --git a/src/wrapper/repository_wrapper.hpp b/src/wrapper/repository_wrapper.hpp
index 99e36ae..2751194 100644
--- a/src/wrapper/repository_wrapper.hpp
+++ b/src/wrapper/repository_wrapper.hpp
@@ -13,6 +13,8 @@
 #include "../wrapper/index_wrapper.hpp"
 #include "../wrapper/object_wrapper.hpp"
 #include "../wrapper/refs_wrapper.hpp"
+#include "../wrapper/remote_wrapper.hpp"
+#include "../wrapper/revwalk_wrapper.hpp"
 #include "../wrapper/signature_wrapper.hpp"
 #include "../wrapper/wrapper_base.hpp"
 
@@ -29,11 +31,21 @@ 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();
 
-    // References
+    bool is_bare() const;
+    bool is_shallow() const;
+
+    revwalk_wrapper new_walker();
+
+    // Head
+    bool is_head_unborn() const;
     reference_wrapper head() const;
+    std::string head_short_name() const;
+
+    // References
     reference_wrapper find_reference(std::string_view ref_name) const;
     std::optional<reference_wrapper> find_reference_dwim(std::string_view ref_name) const;
 
@@ -70,9 +82,20 @@ 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);
 
+    // Remotes
+    remote_wrapper find_remote(std::string_view name) const;
+    remote_wrapper create_remote(std::string_view name, std::string_view url);
+    void delete_remote(std::string_view name);
+    void rename_remote(std::string_view old_name, std::string_view new_name);
+    void set_remote_url(std::string_view name, std::string_view url, bool push = false);
+    std::vector<std::string> list_remotes() const;
+
 private:
 
     repository_wrapper() = default;
diff --git a/src/wrapper/revwalk_wrapper.cpp b/src/wrapper/revwalk_wrapper.cpp
new file mode 100644
index 0000000..65ef0e5
--- /dev/null
+++ b/src/wrapper/revwalk_wrapper.cpp
@@ -0,0 +1,31 @@
+#include <git2/index.h>
+#include <git2/types.h>
+
+#include "revwalk_wrapper.hpp"
+#include "../utils/git_exception.hpp"
+
+revwalk_wrapper::revwalk_wrapper(git_revwalk* walker)
+    : base_type(walker)
+{
+}
+
+revwalk_wrapper::~revwalk_wrapper()
+{
+    git_revwalk_free(p_resource);
+    p_resource=nullptr;
+}
+
+void revwalk_wrapper::push_head()
+{
+    throw_if_error(git_revwalk_push_head(*this));
+}
+
+void revwalk_wrapper::push(git_oid& commit_oid)
+{
+    throw_if_error(git_revwalk_push(*this, &commit_oid));
+}
+
+int revwalk_wrapper::next(git_oid& commit_oid)
+{
+    return git_revwalk_next(&commit_oid, *this);
+}
diff --git a/src/wrapper/revwalk_wrapper.hpp b/src/wrapper/revwalk_wrapper.hpp
new file mode 100644
index 0000000..cd1c08f
--- /dev/null
+++ b/src/wrapper/revwalk_wrapper.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <git2.h>
+#include <git2/types.h>
+
+#include "../wrapper/wrapper_base.hpp"
+#include "../wrapper/commit_wrapper.hpp"
+
+class revwalk_wrapper : public wrapper_base<git_revwalk>
+{
+public:
+
+    using base_type = wrapper_base<git_revwalk>;
+
+    ~revwalk_wrapper();
+
+    revwalk_wrapper(revwalk_wrapper&&) noexcept = default;
+    revwalk_wrapper& operator=(revwalk_wrapper&&) noexcept = default;
+
+    void push_head();
+    void push(git_oid& commit_oid);
+    int next(git_oid& commit_oid);
+
+private:
+
+    revwalk_wrapper(git_revwalk* walker);
+
+    friend class repository_wrapper;
+};
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/conftest.py b/test/conftest.py
index aaf2ff5..dc8f1d3 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -3,6 +3,10 @@
 import pytest
 import subprocess
 
+GIT2CPP_TEST_WASM = os.getenv('GIT2CPP_TEST_WASM') == "1"
+
+if GIT2CPP_TEST_WASM:
+    from .conftest_wasm import *
 
 # Fixture to run test in current tmp_path
 @pytest.fixture
@@ -15,8 +19,10 @@ def run_in_tmp_path(tmp_path):
 
 @pytest.fixture(scope="session")
 def git2cpp_path():
-    return Path(__file__).parent.parent / "build" / "git2cpp"
-
+    if GIT2CPP_TEST_WASM:
+        return 'git2cpp'
+    else:
+        return Path(__file__).parent.parent / 'build' / 'git2cpp'
 
 @pytest.fixture
 def xtl_clone(git2cpp_path, tmp_path, run_in_tmp_path):
diff --git a/test/conftest_wasm.py b/test/conftest_wasm.py
new file mode 100644
index 0000000..89d5061
--- /dev/null
+++ b/test/conftest_wasm.py
@@ -0,0 +1,55 @@
+# Extra fixtures used for wasm testing.
+from functools import partial
+from pathlib import Path
+from playwright.sync_api import Page
+import pytest
+import subprocess
+import time
+
+@pytest.fixture(scope="session", autouse=True)
+def run_web_server():
+    with open('serve.log', 'w') as f:
+        cwd = 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
+        proc.terminate()
+
+@pytest.fixture(scope="function", autouse=True)
+def load_page(page: Page):
+    # Load web page at start of every test.
+    page.goto("http://localhost:8000")
+    page.locator("#loaded").wait_for()
+
+def subprocess_run(
+    page: Page,
+    cmd: list[str],
+    *,
+    capture_output: bool = False,
+    cwd: str | None = None,
+    text: bool | None = None
+) -> subprocess.CompletedProcess:
+    if cwd is not None:
+        raise RuntimeError('cwd is not yet supported')
+
+    proc = page.evaluate("async cmd => window.cockle.shellRun(cmd)", cmd)
+    # TypeScript object is auto converted to Python dict.
+    # Want to return subprocess.CompletedProcess, consider namedtuple if this fails in future.
+    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")
+    return subprocess.CompletedProcess(
+        args=cmd,
+        returncode=proc['returncode'],
+        stdout=stdout,
+        stderr=stderr
+    )
+
+@pytest.fixture(scope="function", autouse=True)
+def mock_subprocess_run(page: Page, monkeypatch):
+    monkeypatch.setattr(subprocess, "run", partial(subprocess_run, page))
diff --git a/test/test_branch.py b/test/test_branch.py
index f81bc8c..20c1149 100644
--- a/test/test_branch.py
+++ b/test/test_branch.py
@@ -38,3 +38,15 @@ def test_branch_nogit(git2cpp_path, tmp_path):
     cmd = [git2cpp_path, 'branch']
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p.returncode != 0
+
+def test_branch_new_repo(git2cpp_path, tmp_path, run_in_tmp_path):
+   # tmp_path exists and is empty.
+    assert list(tmp_path.iterdir()) == []
+
+    cmd = [git2cpp_path, 'init']
+    p = subprocess.run(cmd, cwd = tmp_path)
+
+    branch_cmd = [git2cpp_path, 'branch']
+    p_branch = subprocess.run(branch_cmd, cwd = tmp_path)
+
+    assert p_branch.returncode == 0
diff --git a/test/test_clone.py b/test/test_clone.py
index 7ada28e..0461d43 100644
--- a/test/test_clone.py
+++ b/test/test_clone.py
@@ -3,13 +3,37 @@
 
 import pytest
 
+url = "https://github.com/xtensor-stack/xtl.git"
+
 
 def test_clone(git2cpp_path, tmp_path, run_in_tmp_path):
-    url = 'https://github.com/xtensor-stack/xtl.git'
+    clone_cmd = [git2cpp_path, "clone", url]
+    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_clone.returncode == 0
+
+    assert os.path.exists(os.path.join(tmp_path, "xtl"))
+    assert os.path.exists(os.path.join(tmp_path, "xtl/include"))
 
-    clone_cmd = [git2cpp_path, 'clone', url]
-    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd = tmp_path, text=True)
+
+def test_clone_is_bare(git2cpp_path, tmp_path, run_in_tmp_path):
+    clone_cmd = [git2cpp_path, "clone", "--bare", url]
+    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p_clone.returncode == 0
 
-    assert os.path.exists(os.path.join(tmp_path, 'xtl'))
-    assert os.path.exists(os.path.join(tmp_path, 'xtl/include'))
+    status_cmd = [git2cpp_path, "status"]
+    p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_status.returncode != 0
+
+
+def test_clone_shallow(git2cpp_path, tmp_path, run_in_tmp_path):
+    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
diff --git a/test/test_init.py b/test/test_init.py
index aec88a0..1ba018e 100644
--- a/test/test_init.py
+++ b/test/test_init.py
@@ -1,19 +1,25 @@
-from pathlib import Path
 import subprocess
+from pathlib import Path
 
 
 def test_init_in_directory(git2cpp_path, tmp_path):
     # tmp_path exists and is empty.
     assert list(tmp_path.iterdir()) == []
 
-    cmd = [git2cpp_path, 'init', '--bare', str(tmp_path)]
+    cmd = [git2cpp_path, "init", "--bare", str(tmp_path)]
     p = subprocess.run(cmd, capture_output=True)
     assert p.returncode == 0
-    assert p.stdout == b''
-    assert p.stderr == b''
+    assert p.stdout == b""
+    assert p.stderr == b""
 
     assert sorted(map(lambda path: path.name, tmp_path.iterdir())) == [
-        'HEAD', 'config', 'description', 'hooks', 'info', 'objects', 'refs'
+        "HEAD",
+        "config",
+        "description",
+        "hooks",
+        "info",
+        "objects",
+        "refs",
     ]
 
     # TODO: check this is a valid git repo
@@ -24,14 +30,20 @@ def test_init_in_cwd(git2cpp_path, tmp_path, run_in_tmp_path):
     assert list(tmp_path.iterdir()) == []
     assert Path.cwd() == tmp_path
 
-    cmd = [git2cpp_path, 'init', '--bare']
+    cmd = [git2cpp_path, "init", "--bare"]
     p = subprocess.run(cmd, capture_output=True)
     assert p.returncode == 0
-    assert p.stdout == b''
-    assert p.stderr == b''
+    assert p.stdout == b""
+    assert p.stderr == b""
 
     assert sorted(map(lambda path: path.name, tmp_path.iterdir())) == [
-        'HEAD', 'config', 'description', 'hooks', 'info', 'objects', 'refs'
+        "HEAD",
+        "config",
+        "description",
+        "hooks",
+        "info",
+        "objects",
+        "refs",
     ]
 
     # TODO: check this is a valid git repo
@@ -41,38 +53,43 @@ def test_init_not_bare(git2cpp_path, tmp_path):
     # tmp_path exists and is empty.
     assert list(tmp_path.iterdir()) == []
 
-    cmd = [git2cpp_path, 'init', '.']
+    cmd = [git2cpp_path, "init", "."]
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path)
     assert p.returncode == 0
-    assert p.stdout == b''
-    assert p.stderr == b''
+    assert p.stdout == b""
+    assert p.stderr == b""
 
-    # Directory contains just .git directory.
-    assert sorted(map(lambda path: path.name, tmp_path.iterdir())) == ['.git']
+    # Directory contains just .git directory.
+    assert sorted(map(lambda path: path.name, tmp_path.iterdir())) == [".git"]
     # .git directory is a valid repo.
-    assert sorted(map(lambda path: path.name, (tmp_path / '.git').iterdir())) == [
-        'HEAD', 'config', 'description', 'hooks', 'info', 'objects', 'refs'
+    assert sorted(map(lambda path: path.name, (tmp_path / ".git").iterdir())) == [
+        "HEAD",
+        "config",
+        "description",
+        "hooks",
+        "info",
+        "objects",
+        "refs",
     ]
 
     # Would like to use `git2cpp status` but it complains that 'refs/heads/master' not found
-    cmd = [git2cpp_path, 'log']
+    cmd = [git2cpp_path, "log"]
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path)
     assert p.returncode == 0
-    assert p.stdout == b''
-    assert p.stderr == b''
+    assert b"does not have any commits yet" in p.stdout
 
 
 def test_error_on_unknown_option(git2cpp_path):
-    cmd = [git2cpp_path, 'init', '--unknown']
+    cmd = [git2cpp_path, "init", "--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")
 
 
 def test_error_on_repeated_directory(git2cpp_path):
-    cmd = [git2cpp_path, 'init', 'abc', 'def']
+    cmd = [git2cpp_path, "init", "abc", "def"]
     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: def")
diff --git a/test/test_remote.py b/test/test_remote.py
new file mode 100644
index 0000000..f382b3d
--- /dev/null
+++ b/test/test_remote.py
@@ -0,0 +1,460 @@
+import subprocess
+
+import pytest
+
+repo_url = "https://github.com/user/repo.git"
+
+
+def test_remote_list_empty(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test listing remotes in a repo with no remotes."""
+    # Initialize a repo
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    cmd = [git2cpp_path, "remote"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode == 0
+    assert p.stdout == ""  # No remotes yet
+
+
+def test_remote_add(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test adding a remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    missing_cmd = [git2cpp_path, "remote", "add", "origin"]
+    p_missing = subprocess.run(missing_cmd, capture_output=True, text=True)
+    assert p_missing.returncode != 0
+    assert "usage: git remote add <name> <url>" in p_missing.stderr
+
+    add_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add = subprocess.run(add_cmd, capture_output=True, text=True)
+    assert p_add.returncode == 0
+
+    # Verify remote was added
+    list_cmd = [git2cpp_path, "remote"]
+    p_list = subprocess.run(list_cmd, capture_output=True, text=True)
+    assert p_list.returncode == 0
+    assert "origin" in p_list.stdout
+
+
+def test_remote_add_multiple(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test adding multiple remotes."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_origin_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add_origin = subprocess.run(add_origin_cmd, capture_output=True, check=True)
+    assert p_add_origin.returncode == 0
+    add_upstream_cmd = [
+        git2cpp_path,
+        "remote",
+        "add",
+        "upstream",
+        "https://github.com/upstream/repo.git",
+    ]
+    p_add_upstream = subprocess.run(add_upstream_cmd, capture_output=True, check=True)
+    assert p_add_upstream.returncode == 0
+
+    list_cmd = [git2cpp_path, "remote"]
+    p_list = subprocess.run(list_cmd, capture_output=True, text=True)
+    assert p_list.returncode == 0
+    output = p_list.stdout.strip()
+    assert "origin" in output
+    assert "upstream" in output
+
+
+@pytest.mark.parametrize("remove", ["rm", "remove"])
+def test_remote_remove(git2cpp_path, tmp_path, run_in_tmp_path, remove):
+    """Test removing a remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True)
+    assert p_add.returncode == 0
+
+    # Remove the remote
+    remove_cmd = [git2cpp_path, "remote", remove, "origin"]
+    p_remove = subprocess.run(remove_cmd, capture_output=True, text=True)
+    assert p_remove.returncode == 0
+
+    # Verify remote was removed
+    list_cmd = [git2cpp_path, "remote"]
+    p_list = subprocess.run(list_cmd, capture_output=True, text=True)
+    assert p_list.returncode == 0
+    assert "origin" not in p_list.stdout
+
+
+def test_remote_rename(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test renaming a remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True)
+    assert p_add.returncode == 0
+
+    # Rename the remote
+    rename_cmd = [git2cpp_path, "remote", "rename", "origin", "upstream"]
+    p_rename = subprocess.run(rename_cmd, capture_output=True, text=True)
+    assert p_rename.returncode == 0
+
+    # Verify remote was renamed
+    list_cmd = [git2cpp_path, "remote"]
+    p_list = subprocess.run(list_cmd, capture_output=True, text=True)
+    assert p_list.returncode == 0
+    assert "origin" not in p_list.stdout
+    assert "upstream" in p_list.stdout
+
+
+def test_remote_set_url(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test setting remote URL."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True)
+    assert p_add.returncode == 0
+
+    # Change the URL
+    new_url = "https://github.com/user/newrepo.git"
+    set_url_cmd = [git2cpp_path, "remote", "set-url", "origin", new_url]
+    p_set_url = subprocess.run(set_url_cmd, capture_output=True, text=True)
+    assert p_set_url.returncode == 0
+
+    # Verify URL was changed
+    show_cmd = [git2cpp_path, "remote", "show", "origin"]
+    p_show = subprocess.run(show_cmd, capture_output=True, text=True)
+    assert p_show.returncode == 0
+    assert new_url in p_show.stdout
+
+
+def test_remote_set_push_url(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test setting remote push URL."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    subprocess.run(
+        [git2cpp_path, "remote", "add", "origin", repo_url],
+        capture_output=True,
+        check=True,
+    )
+
+    # Set push URL
+    push_url = "https://github.com/user/pushrepo.git"
+    cmd = [git2cpp_path, "remote", "set-url", "--push", "origin", push_url]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode == 0
+
+    # Verify push URL was set
+    show_cmd = [git2cpp_path, "remote", "show", "origin"]
+    p_show = subprocess.run(show_cmd, capture_output=True, text=True)
+    assert p_show.returncode == 0
+    assert push_url in p_show.stdout
+
+
+def test_remote_show(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test showing remote details."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    subprocess.run(
+        [git2cpp_path, "remote", "add", "origin", repo_url],
+        capture_output=True,
+        check=True,
+    )
+
+    cmd = [git2cpp_path, "remote", "show", "origin"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode == 0
+    assert "origin" in p.stdout
+    assert repo_url in p.stdout
+
+
+def test_remote_show_verbose(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test showing remotes with verbose flag."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    subprocess.run(
+        [git2cpp_path, "remote", "add", "origin", repo_url],
+        capture_output=True,
+        check=True,
+    )
+
+    cmd = [git2cpp_path, "remote", "-v"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode == 0
+    assert "origin" in p.stdout
+    assert repo_url in p.stdout
+    assert "(fetch)" in p.stdout or "(push)" in p.stdout
+
+
+def test_remote_show_all_verbose(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test showing all remotes with verbose flag."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_origin_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add_origin = subprocess.run(add_origin_cmd, capture_output=True, check=True)
+    assert p_add_origin.returncode == 0
+    add_upstream_cmd = [
+        git2cpp_path,
+        "remote",
+        "add",
+        "upstream",
+        "https://github.com/upstream/repo.git",
+    ]
+    p_add_upstream = subprocess.run(add_upstream_cmd, capture_output=True, check=True)
+    assert p_add_upstream.returncode == 0
+
+    show_cmd = [git2cpp_path, "remote", "show", "-v"]
+    p_show = subprocess.run(show_cmd, capture_output=True, text=True)
+    assert p_show.returncode == 0
+    assert "origin" in p_show.stdout
+    assert "upstream" in p_show.stdout
+
+
+def test_remote_error_on_duplicate_add(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test error when adding duplicate remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    add_cmd = [git2cpp_path, "remote", "add", "origin", repo_url]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True)
+    assert p_add.returncode == 0
+
+    # Try to add duplicate
+    add_dup_cmd = [
+        git2cpp_path,
+        "remote",
+        "add",
+        "origin",
+        "https://github.com/user/other.git",
+    ]
+    p_add_dup = subprocess.run(add_dup_cmd, capture_output=True, text=True)
+    assert p_add_dup.returncode != 0
+
+
+def test_remote_error_on_remove_nonexistent(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test error when removing non-existent remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    cmd = [git2cpp_path, "remote", "remove", "nonexistent"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode != 0
+
+
+def test_remote_error_on_rename_nonexistent(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test error when renaming non-existent remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    cmd = [git2cpp_path, "remote", "rename", "nonexistent", "new"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode != 0
+
+
+def test_remote_error_on_show_nonexistent(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Test error when showing non-existent remote."""
+    p_init = subprocess.run([git2cpp_path, "init"], capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    cmd = [git2cpp_path, "remote", "show", "nonexistent"]
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    assert p.returncode != 0
+
+
+@pytest.fixture
+def repo_with_remote(git2cpp_path, tmp_path, run_in_tmp_path):
+    """Fixture that creates a repo with a remote pointing to a local bare repo."""
+    # Create a bare repo to use as remote
+    remote_path = tmp_path / "remote_repo"
+    remote_path.mkdir()
+    init_cmd = [git2cpp_path, "init", "--bare", str(remote_path)]
+    p_init = subprocess.run(init_cmd, capture_output=True, check=True)
+    assert p_init.returncode == 0
+
+    # Create a regular repo
+    local_path = tmp_path / "local_repo"
+    local_path.mkdir()
+
+    # Initialize repo in the directory
+    p_init_2 = subprocess.run(
+        [git2cpp_path, "init"], capture_output=True, check=True, cwd=local_path
+    )
+    assert p_init_2.returncode == 0
+
+    # Add remote
+    add_cmd = [git2cpp_path, "remote", "add", "origin", str(remote_path)]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True, cwd=local_path)
+    assert p_add.returncode == 0
+
+    return local_path, remote_path
+
+
+def test_fetch_from_remote(git2cpp_path, repo_with_remote):
+    """Test fetching from a 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  /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
+    assert p.returncode in [0, 1]  # 0 for success, 1 for no refs/error
+
+
+def test_fetch_default_origin(git2cpp_path, repo_with_remote):
+    """Test fetching with default origin."""
+    local_path, remote_path = repo_with_remote
+
+    cmd = [git2cpp_path, "fetch"]
+    p = subprocess.run(cmd, capture_output=True, text=True, cwd=local_path)
+    # Fetch might succeed (empty) or fail (no refs), but shouldn't crash
+    assert p.returncode in [0, 1]
+
+
+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("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
+    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
+
+    depth_cmd = [git2cpp_path, "fetch", "--depth", "3"]
+    p_depth = subprocess.run(depth_cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p_depth.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_unshallow(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
+
+    unshallow_cmd = [git2cpp_path, "fetch", "--unshallow"]
+    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)
+    assert p_log_2.returncode == 0
+    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()
+    xtl_path = tmp_path / "xtl"
+
+    cmd = [git2cpp_path, "remote"]
+    p = subprocess.run(cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p.returncode == 0
+    assert "origin" in p.stdout
+
+
+def test_remote_show_in_cloned_repo(xtl_clone, git2cpp_path, tmp_path):
+    """Test showing remote in cloned repo."""
+    assert (tmp_path / "xtl").exists()
+    xtl_path = tmp_path / "xtl"
+
+    cmd = [git2cpp_path, "remote", "show", "origin"]
+    p = subprocess.run(cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p.returncode == 0
+    assert "origin" in p.stdout
+    # Should contain URL information
+    assert "http" in p.stdout or "git" in p.stdout or "https" in p.stdout
+
+
+def test_push_local(xtl_clone, git_config, git2cpp_path, tmp_path, monkeypatch):
+    """Test setting push on a local remote."""
+    assert (tmp_path / "xtl").exists()
+    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
+    )
+    assert p_checkout.returncode == 0
+
+    p = xtl_path / "mook_file.txt"
+    p.write_text("")
+
+    cmd_add = [git2cpp_path, "add", "mook_file.txt"]
+    p_add = subprocess.run(cmd_add, cwd=xtl_path, text=True)
+    assert p_add.returncode == 0
+
+    cmd_commit = [git2cpp_path, "commit", "-m", "test commit"]
+    p_commit = subprocess.run(cmd_commit, cwd=xtl_path, text=True)
+    assert p_commit.returncode == 0
+
+    url = "https://github.com/xtensor-stack/xtl.git"
+    local_path = tmp_path / "local_repo"
+    clone_cmd = [git2cpp_path, "clone", "--bare", url, local_path]
+    p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True)
+    assert p_clone.returncode == 0
+
+    add_cmd = [git2cpp_path, "remote", "add", "local_repo", str(local_path)]
+    p_add = subprocess.run(add_cmd, capture_output=True, check=True, cwd=xtl_path)
+    assert p_add.returncode == 0
+
+    cmd_push = [git2cpp_path, "push", "local_repo"]  # "foregone"
+    p_push = subprocess.run(cmd_push, capture_output=True, check=True, cwd=xtl_path)
+    assert p_push.returncode == 0
+
+    list_cmd = [git2cpp_path, "branch"]
+    p_list = subprocess.run(list_cmd, capture_output=True, cwd=local_path, text=True)
+    assert p_list.returncode == 0
+    assert "foregone" in p_list.stdout
diff --git a/test/test_revlist.py b/test/test_revlist.py
new file mode 100644
index 0000000..870b041
--- /dev/null
+++ b/test/test_revlist.py
@@ -0,0 +1,20 @@
+import subprocess
+
+import pytest
+
+
+def test_revlist(xtl_clone, git_config, git2cpp_path, tmp_path, monkeypatch):
+    assert (tmp_path / "xtl").exists()
+    xtl_path = tmp_path / "xtl"
+
+    cmd = [
+        git2cpp_path,
+        "rev-list",
+        "35955995424eb9699bb604b988b5270253b1fccc",
+        "--max-count",
+        "2",
+    ]
+    p = subprocess.run(cmd, capture_output=True, cwd=xtl_path, text=True)
+    assert p.returncode == 0
+    assert "da1754dd6" in p.stdout
+    assert "2da8e13ef" not in p.stdout
diff --git a/test/test_revparse.py b/test/test_revparse.py
new file mode 100644
index 0000000..af99577
--- /dev/null
+++ b/test/test_revparse.py
@@ -0,0 +1,31 @@
+import subprocess
+
+import pytest
+
+
+def test_revparse_bare(git2cpp_path, tmp_path, run_in_tmp_path):
+    # tmp_path exists and is empty.
+    assert list(tmp_path.iterdir()) == []
+
+    cmd = [git2cpp_path, "init", "--bare"]
+    p = subprocess.run(cmd, cwd=tmp_path)
+    assert p.returncode == 0
+
+    cmd2 = [git2cpp_path, "rev-parse", "--is-bare-repository"]
+    p2 = subprocess.run(cmd2, capture_output=True, text=True, cwd=tmp_path)
+    assert p2.returncode == 0
+    assert p2.stdout == "true\n"
+
+
+def test_revparse_shallow(git2cpp_path, tmp_path, run_in_tmp_path):
+    url = "https://github.com/xtensor-stack/xtl.git"
+    cmd = [git2cpp_path, "clone", "--depth", "1", url]
+    p = subprocess.run(cmd, capture_output=True, text=True, cwd=tmp_path)
+    assert p.returncode == 0
+    assert (tmp_path / "xtl").exists()
+
+    xtl_path = tmp_path / "xtl"
+    cmd2 = [git2cpp_path, "rev-parse", "--is-shallow-repository"]
+    p2 = subprocess.run(cmd2, capture_output=True, text=True, cwd=xtl_path)
+    assert p2.returncode == 0
+    assert p2.stdout == "true\n"
diff --git a/test/test_status.py b/test/test_status.py
index ab7288e..93a632c 100644
--- a/test/test_status.py
+++ b/test/test_status.py
@@ -11,15 +11,15 @@ def test_status_new_file(xtl_clone, git2cpp_path, tmp_path, short_flag, long_fla
     assert (tmp_path / "xtl").exists()
     xtl_path = tmp_path / "xtl"
 
-    p = xtl_path / "mook_file.txt"   # Untracked files
-    p.write_text('')
+    p = xtl_path / "mook_file.txt"  # Untracked files
+    p.write_text("")
 
-    pw = xtl_path / "CMakeLists.txt"   # Changes not staged for commit / modified
+    pw = xtl_path / "CMakeLists.txt"  # Changes not staged for commit / modified
     pw.write_text("blablabla")
 
-    os.remove(xtl_path / "README.md")   # Changes not staged for commit / deleted
+    os.remove(xtl_path / "README.md")  # Changes not staged for commit / deleted
 
-    cmd = [git2cpp_path, 'status']
+    cmd = [git2cpp_path, "status"]
     if short_flag != "":
         cmd.append(short_flag)
     if long_flag != "":
@@ -38,27 +38,29 @@ def test_status_new_file(xtl_clone, git2cpp_path, tmp_path, short_flag, long_fla
         assert " D " in p.stdout
         assert "?? " in p.stdout
 
+
 def test_status_nogit(git2cpp_path, tmp_path):
-    cmd = [git2cpp_path, 'status']
+    cmd = [git2cpp_path, "status"]
     p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)
     assert p.returncode != 0
 
+
 @pytest.mark.parametrize("short_flag", ["", "-s", "--short"])
 @pytest.mark.parametrize("long_flag", ["", "--long"])
 def test_status_add_file(xtl_clone, git2cpp_path, tmp_path, short_flag, long_flag):
     assert (tmp_path / "xtl").exists()
     xtl_path = tmp_path / "xtl"
 
-    p = xtl_path / "mook_file.txt"   # Changes to be committed / new file
-    p.write_text('')
+    p = xtl_path / "mook_file.txt"  # Changes to be committed / new file
+    p.write_text("")
 
-    os.remove(xtl_path / "README.md")   # Changes to be committed / deleted
+    os.remove(xtl_path / "README.md")  # Changes to be committed / deleted
 
-    cmd_add = [git2cpp_path, 'add', "--all"]
+    cmd_add = [git2cpp_path, "add", "--all"]
     p_add = subprocess.run(cmd_add, cwd=xtl_path, text=True)
     assert p_add.returncode == 0
 
-    cmd_status = [git2cpp_path, 'status']
+    cmd_status = [git2cpp_path, "status"]
     if short_flag != "":
         cmd_status.append(short_flag)
     if long_flag != "":
@@ -76,3 +78,16 @@ def test_status_add_file(xtl_clone, git2cpp_path, tmp_path, short_flag, long_fla
     elif short_flag in ["-s", "--short"]:
         assert "A  " in p_status.stdout
         assert "D  " in p_status.stdout
+
+
+def test_status_new_repo(git2cpp_path, tmp_path, run_in_tmp_path):
+    # tmp_path exists and is empty.
+    assert list(tmp_path.iterdir()) == []
+
+    cmd = [git2cpp_path, "init"]
+    p = subprocess.run(cmd, cwd=tmp_path)
+    assert p.returncode == 0
+
+    status_cmd = [git2cpp_path, "status"]
+    p_status = subprocess.run(status_cmd, cwd=tmp_path)
+    assert p_status.returncode == 0
diff --git a/wasm/.gitignore b/wasm/.gitignore
new file mode 100644
index 0000000..a4c0e06
--- /dev/null
+++ b/wasm/.gitignore
@@ -0,0 +1,14 @@
+CMakeCache.txt
+CMakeFiles/
+Makefile
+cmake_install.cmake
+cockle-config.json
+cockle_wasm_env/
+node_modules/
+package-lock.json
+.jupyterlite.doit.db
+
+recipe/em-forge-recipes/
+serve/*/
+test/assets/*/
+test/lib/
diff --git a/wasm/CMakeLists.txt b/wasm/CMakeLists.txt
new file mode 100644
index 0000000..f8a6670
--- /dev/null
+++ b/wasm/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.28)
+project(git2cpp-wasm)
+
+add_subdirectory(recipe)
+add_subdirectory(cockle-deploy)
+add_subdirectory(lite-deploy)
+add_subdirectory(test)
+
+# Build everything (package, cockle and lite deployments, tests).
+add_custom_target(build ALL DEPENDS build-recipe build-cockle build-lite build-test)
+
+# Rebuild after change in C++ code.
+add_custom_target(rebuild DEPENDS rebuild-recipe rebuild-cockle rebuild-lite rebuild-test)
+
+# Serve both cockle and JupyterLite deployments.
+add_custom_target(serve COMMAND npx static-handler --cors --coop --coep --corp serve)
diff --git a/wasm/README.md b/wasm/README.md
new file mode 100644
index 0000000..899c0d2
--- /dev/null
+++ b/wasm/README.md
@@ -0,0 +1,80 @@
+# Building and testing git2cpp in WebAssembly
+
+This directory contains everything needed to build the local `git2cpp` source code as an
+WebAssembly [Emscripten-forge](https://emscripten-forge.org/) package, create local
+[cockle](https://github.com/jupyterlite/cockle) and
+[JupyterLite terminal](https://github.com/jupyterlite/terminal) deployments that run in a browser,
+and test the WebAssembly build.
+
+It works on Linux and macOS but not Windows.
+
+There are 5 sub-directories:
+
+- `recipe`: build local `git2cpp` source code into an Emscripten-forge package.
+- `cockle-deploy`: create a `cockle` deployment in the `serve` directory.
+- `lite-deploy`: create a JupyterLite `terminal` deployment in the `serve` directory.
+- `serve`: where the two deployments are served from.
+- `test`: test the WebAssembly build.
+
+## Build and deploy
+
+The build, deploy and test process uses a separate `micromamba` environment defined in
+`wasm-environment.yml`. To set this up use from within this directory:
+
+```bash
+micromamba create -f wasm-environment.yml
+micromamba activate git2cpp-wasm
+```
+
+Then to build the WebAssembly package, both deployments and the testing resources use:
+
+```bash
+cmake .
+make
+```
+
+The built emscripten-forge package will be file named something like `git2cpp-0.0.5-h7223423_1.tar.bz2`
+in the directory `recipe/em-force-recipes/output/emscripten-wasm32`.
+
+The local deployments in the `serve` directory can be manually checked using:
+
+```bash
+make serve
+```
+
+and open a web browser at http://localhost:8080/. Confirm that the local build of `git2cpp` is being
+used in the two deployments by running `cockle-config package` at the command line, the output
+should be something like:
+
+<img alt="cockle-config output" src="cockle-config.png">
+
+Note that the `source` for the `git2cpp` package is the local filesystem rather than from
+`prefix.dev`. The version number of `git2cpp` in this table is not necessarily correct as it is the
+version number of the current Emscripten-forge recipe rather than the version of the local `git2cpp`
+source code which can be checked using `git2cpp -v` at the `cockle`/`terminal` command line.
+
+## Test
+
+To test the WebAssembly build use:
+
+```bash
+make test
+```
+
+This runs (some of) the tests in the top-level `test` directory with various monkey patching so that
+`git2cpp` commands are executed in the browser. If there are problems running the tests then ensure
+you have the latest `playwright` browser installed:
+
+
+```bash
+playwright install chromium
+```
+
+## Rebuild
+
+After making changes to the local `git2cpp` source code you can rebuild the WebAssembly package,
+both deployments and test code using:
+
+```bash
+make rebuild
+```
diff --git a/wasm/cockle-config.png b/wasm/cockle-config.png
new file mode 100644
index 0000000..c38454d
Binary files /dev/null and b/wasm/cockle-config.png differ
diff --git a/wasm/cockle-deploy/CMakeLists.txt b/wasm/cockle-deploy/CMakeLists.txt
new file mode 100644
index 0000000..3cbc66e
--- /dev/null
+++ b/wasm/cockle-deploy/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.28)
+project(git2cpp-wasm-cockle-deploy)
+
+include("../common.cmake")
+
+set(SERVE_DIR "../serve/cockle")
+
+add_custom_target(build-cockle
+    DEPENDS build-recipe
+    COMMAND npm install
+    COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} npm run build
+    BYPRODUCTS cockle_wasm_env node_modules ${SERVE_DIR}
+)
+
+add_custom_target(rebuild-cockle
+    DEPENDS rebuild-recipe clean-env-cockle build-cockle
+)
+
+add_custom_target(clean-env-cockle
+    COMMAND ${CMAKE_COMMAND} -E remove_directory cockle_wasm_env
+)
diff --git a/wasm/cockle-deploy/assets/index.html b/wasm/cockle-deploy/assets/index.html
new file mode 100644
index 0000000..1b1b8cc
--- /dev/null
+++ b/wasm/cockle-deploy/assets/index.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>cockle-deployment for git2cpp</title>
+    <script src="bundle.js"></script>
+</head>
+<body>
+    <div id="targetdiv"></div>
+</body>
+</html>
diff --git a/wasm/cockle-deploy/cockle-config-in.json b/wasm/cockle-deploy/cockle-config-in.json
new file mode 100644
index 0000000..bbb59a1
--- /dev/null
+++ b/wasm/cockle-deploy/cockle-config-in.json
@@ -0,0 +1,19 @@
+{
+  "packages": {
+    "git2cpp": {},
+    "nano": {},
+    "tree": {},
+    "vim": {}
+  },
+  "aliases": {
+    "git": "git2cpp",
+    "vi": "vim"
+  },
+  "environment": {
+    "GIT_CORS_PROXY": "https://corsproxy.io/?url=",
+    "GIT_AUTHOR_NAME": "Jane Doe",
+    "GIT_AUTHOR_EMAIL": "jane.doe@blabla.com",
+    "GIT_COMMITTER_NAME": "Jane Doe",
+    "GIT_COMMITTER_EMAIL": "jane.doe@blabla.com"
+  }
+}
diff --git a/wasm/cockle-deploy/package.json b/wasm/cockle-deploy/package.json
new file mode 100644
index 0000000..4830e3d
--- /dev/null
+++ b/wasm/cockle-deploy/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "cockle-deploy",
+  "scripts": {
+    "build": "rspack build",
+    "postbuild": "npm run postbuild:wasm && npm run postbuild:index",
+    "postbuild:wasm": "node node_modules/@jupyterlite/cockle/lib/tools/prepare_wasm.js --copy ../serve/cockle/",
+    "postbuild:index": "cp assets/index.html ../serve/cockle/"
+  },
+  "main": "../serve/cockle/index.js",
+  "types": "../serve/cockle/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@rspack/cli": "^1.0.4",
+    "@rspack/core": "^1.0.4",
+    "css-loader": "^7.1.2",
+    "style-loader": "^4.0.0",
+    "ts-loader": "^9.5.1",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "@jupyterlite/cockle": "^1.3.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
+    "deepmerge-ts": "^7.1.4"
+  }
+}
diff --git a/wasm/cockle-deploy/rspack.config.js b/wasm/cockle-deploy/rspack.config.js
new file mode 100644
index 0000000..d6e29ff
--- /dev/null
+++ b/wasm/cockle-deploy/rspack.config.js
@@ -0,0 +1,29 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'development',
+  entry: './src/index.ts',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/,
+      },
+      {
+        test: /\.css$/,
+        use: [
+          'style-loader',
+          'css-loader'
+        ]
+      }
+    ]
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+  },
+  output: {
+    filename: 'bundle.js',
+    path: path.resolve(__dirname, '../serve/cockle'),
+  }
+};
diff --git a/wasm/cockle-deploy/src/defs.ts b/wasm/cockle-deploy/src/defs.ts
new file mode 100644
index 0000000..a44acd7
--- /dev/null
+++ b/wasm/cockle-deploy/src/defs.ts
@@ -0,0 +1,10 @@
+import { IShellManager } from '@jupyterlite/cockle';
+
+export namespace IDeployment {
+  export interface IOptions {
+    baseUrl: string;
+    browsingContextId: string;
+    shellManager: IShellManager;
+    targetDiv: HTMLElement;
+  }
+}
diff --git a/wasm/cockle-deploy/src/deployment.ts b/wasm/cockle-deploy/src/deployment.ts
new file mode 100644
index 0000000..e10b1ca
--- /dev/null
+++ b/wasm/cockle-deploy/src/deployment.ts
@@ -0,0 +1,63 @@
+import { Shell } from '@jupyterlite/cockle'
+import { FitAddon } from '@xterm/addon-fit'
+import { Terminal } from '@xterm/xterm'
+import { IDeployment } from './defs'
+
+export class Deployment {
+  constructor(options: IDeployment.IOptions) {
+    this._targetDiv = options.targetDiv;
+
+    const termOptions = {
+      rows: 50,
+      theme: {
+        foreground: "ivory",
+        background: "#111111",
+        cursor: "silver"
+      },
+    }
+    this._term = new Terminal(termOptions)
+
+    this._fitAddon = new FitAddon()
+    this._term.loadAddon(this._fitAddon)
+
+    const { baseUrl, browsingContextId, shellManager } = options;
+
+    this._shell = new Shell({
+      browsingContextId,
+      baseUrl,
+      wasmBaseUrl: baseUrl,
+      shellManager,
+      outputCallback: this.outputCallback.bind(this),
+    })
+  }
+
+  async start(): Promise<void> {
+    this._term!.onResize(async (arg: any) => await this.onResize(arg))
+    this._term!.onData(async (data: string) => await this.onData(data))
+
+    const resizeObserver = new ResizeObserver((entries) => {
+      this._fitAddon!.fit()
+    })
+
+    this._term!.open(this._targetDiv)
+    await this._shell.start()
+    resizeObserver.observe(this._targetDiv)
+  }
+
+  async onData(data: string): Promise<void> {
+    await this._shell.input(data)
+  }
+
+  async onResize(arg: any): Promise<void> {
+    await this._shell.setSize(arg.rows, arg.cols)
+  }
+
+  private outputCallback(text: string): void {
+    this._term!.write(text)
+  }
+
+  private _targetDiv: HTMLElement;
+  private _term: Terminal
+  private _fitAddon: FitAddon
+  private _shell: Shell
+}
diff --git a/wasm/cockle-deploy/src/index.ts b/wasm/cockle-deploy/src/index.ts
new file mode 100644
index 0000000..ac63e63
--- /dev/null
+++ b/wasm/cockle-deploy/src/index.ts
@@ -0,0 +1,13 @@
+import { ShellManager } from '@jupyterlite/cockle';
+import "./style/deployment.css"
+import { Deployment } from "./deployment";
+
+document.addEventListener("DOMContentLoaded", async () => {
+  const baseUrl = window.location.href;
+  const shellManager = new ShellManager();
+  const browsingContextId = await shellManager.installServiceWorker(baseUrl);
+
+  const targetDiv: HTMLElement = document.getElementById('targetdiv')!;
+  const playground = new Deployment({ baseUrl, browsingContextId, shellManager, targetDiv });
+  await playground.start();
+})
diff --git a/wasm/cockle-deploy/src/style/deployment.css b/wasm/cockle-deploy/src/style/deployment.css
new file mode 100644
index 0000000..a4f26b4
--- /dev/null
+++ b/wasm/cockle-deploy/src/style/deployment.css
@@ -0,0 +1,10 @@
+@import '~@xterm/xterm/css/xterm.css';
+
+body {
+  background-color: darkslategray;
+}
+
+#targetdiv {
+  border: 2px solid black;
+  height: 100%;
+}
diff --git a/wasm/cockle-deploy/tsconfig.json b/wasm/cockle-deploy/tsconfig.json
new file mode 100644
index 0000000..89b3e89
--- /dev/null
+++ b/wasm/cockle-deploy/tsconfig.json
@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "composite": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "incremental": true,
+    "lib": ["es2022", "webworker"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "preserveWatchOutput": true,
+    "resolveJsonModule": true,
+    "outDir": "../serve/cockle",
+    "rootDir": "src",
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "es2022",
+    "sourceMap": true
+  },
+  "include": ["src/**/*"]
+}
diff --git a/wasm/common.cmake b/wasm/common.cmake
new file mode 100644
index 0000000..787dd0a
--- /dev/null
+++ b/wasm/common.cmake
@@ -0,0 +1,8 @@
+# Emscripten-forge recipes directory relative to 'recipe' directory
+set(EM_FORGE_RECIPES_DIR "em-forge-recipes")
+
+# Output directory for built emscripten-forge packages relative to EM_FORGE_RECIPES_DIR
+set(BUILT_PACKAGE_SUBDIR "output")
+
+# Output directory for built emscripten-forge packages relative to subdirectories of this directory
+set(BUILT_PACKAGE_DIR "../recipe/${EM_FORGE_RECIPES_DIR}/${BUILT_PACKAGE_SUBDIR}")
diff --git a/wasm/lite-deploy/CMakeLists.txt b/wasm/lite-deploy/CMakeLists.txt
new file mode 100644
index 0000000..1ba6b5b
--- /dev/null
+++ b/wasm/lite-deploy/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.28)
+project(git2cpp-wasm-lite-deploy)
+
+include("../common.cmake")
+
+set(SERVE_DIR "../serve/lite")
+
+add_custom_target(build-lite
+    DEPENDS build-recipe
+    COMMAND jupyter lite --version
+    COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} jupyter lite build --output-dir ${SERVE_DIR}
+    BYPRODUCTS cockle-config.json .cockle_temp/ .jupyterlite.doit.db cockle_wasm_env/ ${SERVE_DIR}
+)
+
+add_custom_target(rebuild-lite
+    DEPENDS rebuild-recipe clean-env-lite build-lite
+)
+
+add_custom_target(clean-env-lite
+    COMMAND ${CMAKE_COMMAND} -E remove_directory cockle_wasm_env
+)
diff --git a/wasm/lite-deploy/cockle-config-in.json b/wasm/lite-deploy/cockle-config-in.json
new file mode 100644
index 0000000..bbb59a1
--- /dev/null
+++ b/wasm/lite-deploy/cockle-config-in.json
@@ -0,0 +1,19 @@
+{
+  "packages": {
+    "git2cpp": {},
+    "nano": {},
+    "tree": {},
+    "vim": {}
+  },
+  "aliases": {
+    "git": "git2cpp",
+    "vi": "vim"
+  },
+  "environment": {
+    "GIT_CORS_PROXY": "https://corsproxy.io/?url=",
+    "GIT_AUTHOR_NAME": "Jane Doe",
+    "GIT_AUTHOR_EMAIL": "jane.doe@blabla.com",
+    "GIT_COMMITTER_NAME": "Jane Doe",
+    "GIT_COMMITTER_EMAIL": "jane.doe@blabla.com"
+  }
+}
diff --git a/wasm/lite-deploy/jupyter-lite.json b/wasm/lite-deploy/jupyter-lite.json
new file mode 100644
index 0000000..31aaf07
--- /dev/null
+++ b/wasm/lite-deploy/jupyter-lite.json
@@ -0,0 +1,6 @@
+{
+  "jupyter-lite-schema-version": 0,
+  "jupyter-config-data": {
+    "terminalsAvailable": true
+  }
+}
diff --git a/wasm/recipe/CMakeLists.txt b/wasm/recipe/CMakeLists.txt
new file mode 100644
index 0000000..48560e9
--- /dev/null
+++ b/wasm/recipe/CMakeLists.txt
@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.28)
+project(git2cpp-wasm-recipe)
+
+include("../common.cmake")
+
+set(EM_FORGE_RECIPES_REPO "https://github.com/emscripten-forge/recipes")
+set(GIT2CPP_RECIPE_DIR "recipes/recipes_emscripten/git2cpp")
+set(RATTLER_ARGS "--package-format tar-bz2 --target-platform emscripten-wasm32 -c https://repo.prefix.dev/emscripten-forge-dev -c microsoft -c conda-forge")
+
+# Only want the git2cpp recipe from emscripten-forge/recipes repo, not the whole repo.
+# Note removing the .git directory otherwise `git clean -fxd` will not remove the directory.
+add_custom_command(
+    OUTPUT ${EM_FORGE_RECIPES_DIR}
+    COMMAND git clone --no-checkout ${EM_FORGE_RECIPES_REPO} --depth 1 ${EM_FORGE_RECIPES_DIR}
+	COMMAND cd ${EM_FORGE_RECIPES_DIR} && git sparse-checkout init
+	COMMAND cd ${EM_FORGE_RECIPES_DIR} && git sparse-checkout set ${GIT2CPP_RECIPE_DIR}
+	COMMAND cd ${EM_FORGE_RECIPES_DIR} && git checkout main
+    COMMAND ${CMAKE_COMMAND} -E remove_directory ${EM_FORGE_RECIPES_DIR}/.git
+)
+
+add_custom_target(modify-recipe
+    DEPENDS ${EM_FORGE_RECIPES_DIR}
+    COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/modify-recipe.py ${GIT2CPP_RECIPE_DIR}
+    WORKING_DIRECTORY ${EM_FORGE_RECIPES_DIR}
+)
+
+add_custom_command(
+    OUTPUT ${EM_FORGE_RECIPES_DIR}/${BUILT_PACKAGE_SUBDIR}
+    DEPENDS modify-recipe
+    COMMAND bash -c "rattler-build build ${RATTLER_ARGS} --recipe ${GIT2CPP_RECIPE_DIR}"
+    WORKING_DIRECTORY ${EM_FORGE_RECIPES_DIR}
+)
+
+add_custom_target(build-recipe
+    DEPENDS ${EM_FORGE_RECIPES_DIR}/${BUILT_PACKAGE_SUBDIR}
+    WORKING_DIRECTORY ${EM_FORGE_RECIPES_DIR}
+)
+
+add_custom_target(rebuild-recipe DEPENDS clean-output-dir build-recipe)
+
+add_custom_target(clean-output-dir
+    COMMAND ${CMAKE_COMMAND} -E remove_directory ${EM_FORGE_RECIPES_DIR}/${BUILT_PACKAGE_SUBDIR}
+)
diff --git a/wasm/recipe/modify-recipe.py b/wasm/recipe/modify-recipe.py
new file mode 100644
index 0000000..70a3d83
--- /dev/null
+++ b/wasm/recipe/modify-recipe.py
@@ -0,0 +1,49 @@
+# Modify the git2cpp emscripten-forge recipe to build from the local repo.
+# This can be called repeatedly and will produce the same output.
+
+from pathlib import Path
+import shutil
+import sys
+import yaml
+
+
+def quit(msg):
+    print(msg)
+    exit(1)
+
+if len(sys.argv) < 2:
+    quit(f'Usage: {sys.argv[0]} <recipe directory containing yaml file to modify>')
+
+input_dir = Path(sys.argv[1])
+if not input_dir.is_dir():
+    quit(f'{input_dir} should exist and be a directory')
+
+input_filename = input_dir / 'recipe.yaml'
+if not input_filename.is_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'
+backup_exists = input_backup.exists()
+if not backup_exists:
+    shutil.copy(input_filename, input_backup)
+
+# Read and parse input backup file which is the original recipe file.
+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
+
+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'] = '../../../../../../'
+
+# Overwrite recipe file.
+with open(input_filename, 'w') as f:
+    yaml.dump(recipe, f)
diff --git a/wasm/serve/index.html b/wasm/serve/index.html
new file mode 100644
index 0000000..61743ea
--- /dev/null
+++ b/wasm/serve/index.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>git2cpp deployments</title>
+</head>
+<body>
+    <h1>Deployments using WebAssembly build of git2cpp branch</h1>
+    <ul>
+        <li><a href="cockle/">cockle</a></li>
+        <li><a href="lite/">JupyterLite terminal</a></li>
+    </ul>
+</body>
+</html>
diff --git a/wasm/test/CMakeLists.txt b/wasm/test/CMakeLists.txt
new file mode 100644
index 0000000..29db8ad
--- /dev/null
+++ b/wasm/test/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.28)
+project(git2cpp-wasm-test)
+
+include("../common.cmake")
+
+add_custom_target(build-test
+    DEPENDS build-recipe
+    COMMAND npm install
+    COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} npm run build
+    BYPRODUCTS cockle_wasm_env lib node_modules
+)
+
+add_custom_target(rebuild-test
+    DEPENDS rebuild-recipe clean-env-test build-test
+)
+
+add_custom_target(test
+	# A pytest fixture ensures that `npm run serve` runs for the duration of the tests.
+    COMMAND GIT2CPP_TEST_WASM=1 pytest -v -rP test_git.py
+    WORKING_DIRECTORY ../../test
+)
+
+add_custom_target(clean-env-test
+    COMMAND ${CMAKE_COMMAND} -E remove_directory cockle_wasm_env
+)
diff --git a/wasm/test/assets/index.html b/wasm/test/assets/index.html
new file mode 100644
index 0000000..57ba584
--- /dev/null
+++ b/wasm/test/assets/index.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Testing git2cpp in cockle</title>
+    <script src="bundle.js"></script>
+</head>
+<body>
+</body>
+</html>
diff --git a/wasm/test/cockle-config-in.json b/wasm/test/cockle-config-in.json
new file mode 100644
index 0000000..bbb59a1
--- /dev/null
+++ b/wasm/test/cockle-config-in.json
@@ -0,0 +1,19 @@
+{
+  "packages": {
+    "git2cpp": {},
+    "nano": {},
+    "tree": {},
+    "vim": {}
+  },
+  "aliases": {
+    "git": "git2cpp",
+    "vi": "vim"
+  },
+  "environment": {
+    "GIT_CORS_PROXY": "https://corsproxy.io/?url=",
+    "GIT_AUTHOR_NAME": "Jane Doe",
+    "GIT_AUTHOR_EMAIL": "jane.doe@blabla.com",
+    "GIT_COMMITTER_NAME": "Jane Doe",
+    "GIT_COMMITTER_EMAIL": "jane.doe@blabla.com"
+  }
+}
diff --git a/wasm/test/package.json b/wasm/test/package.json
new file mode 100644
index 0000000..e4259f6
--- /dev/null
+++ b/wasm/test/package.json
@@ -0,0 +1,23 @@
+{
+    "name": "cockle-test",
+    "version": "1.0.0",
+    "description": "Cockle tests",
+    "license": "BSD-3-Clause",
+    "author": "Ian Thomas",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "private": true,
+    "scripts": {
+        "build": "rspack build",
+        "postbuild": "node node_modules/@jupyterlite/cockle/lib/tools/prepare_wasm.js --copy assets",
+        "serve": "rspack serve"
+    },
+    "devDependencies": {
+        "@jupyterlite/cockle": "^1.3.0",
+        "@rspack/cli": "^0.7.5",
+        "@rspack/core": "^0.7.5",
+        "ts-loader": "^9.5.1",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.5.4"
+    }
+}
diff --git a/wasm/test/rspack.config.js b/wasm/test/rspack.config.js
new file mode 100644
index 0000000..f2fa264
--- /dev/null
+++ b/wasm/test/rspack.config.js
@@ -0,0 +1,36 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'development',
+  entry: './src/index.ts',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/
+      },
+      {
+        test: /\.css$/,
+        use: ['style-loader', 'css-loader']
+      }
+    ]
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js', '.wasm']
+  },
+  output: {
+    filename: 'bundle.js',
+    path: path.resolve(__dirname, 'lib')
+  },
+  devServer: {
+    static: {
+      directory: path.join(__dirname, 'assets')
+    },
+    headers: {
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cross-Origin-Opener-Policy": "same-origin",
+    },
+    port: 8000
+  }
+};
diff --git a/wasm/test/src/index.ts b/wasm/test/src/index.ts
new file mode 100644
index 0000000..37d4ab7
--- /dev/null
+++ b/wasm/test/src/index.ts
@@ -0,0 +1,78 @@
+import { Shell } from '@jupyterlite/cockle';
+import { MockTerminalOutput } from './utils';
+
+interface IReturn {
+  returncode: number;
+  stdout: string;
+  stderr: string;
+}
+
+async function setup() {
+  const baseUrl = 'http://localhost:8000/';
+  const output = new MockTerminalOutput();
+
+  const shell = new Shell({
+    baseUrl,
+    wasmBaseUrl: baseUrl,
+    outputCallback: output.callback,
+    color: false
+  });
+  await shell.start();
+
+  const cockle = {
+    shell,
+    shellRun: (cmd: string[]) => shellRun(shell, output, cmd)
+  };
+
+  (window as any).cockle = cockle;
+
+  // Add div to indicate setup complete which can be awaited at start of tests.
+  const div = document.createElement("div");
+  div.id = 'loaded';
+  div.innerHTML = 'loaded';
+  document.body.appendChild(div);
+}
+
+async function shellRun(
+  shell: Shell,
+  output: MockTerminalOutput,
+  cmd: string[]
+): Promise<IReturn> {
+  // Keep stdout and stderr separate by outputting stdout to temporary file and stderr to terminal,
+  // then read the temporary file to get stdout to return.
+  output.clear();
+  let cmdLine = cmd.join(' ') + '> .outtmp' + '\r';
+  await shell.input(cmdLine);
+
+  const stderr = stripOutput(output.textAndClear(), cmdLine);
+  const returncode = await shell.exitCode();
+
+  // Read stdout from .outtmp file.
+  cmdLine = 'cat .outtmp\r';
+  await shell.input(cmdLine);
+  const stdout = stripOutput(output.textAndClear(), cmdLine);
+
+  // Delete temporary file.
+  cmdLine = 'rm .outtmp\r';
+  await shell.input(cmdLine);
+  output.clear();
+
+  return { returncode, stdout, stderr };
+}
+
+function stripOutput(output: string, cmdLine: string): string {
+  // Remove submitted command line at start.
+  let ret = output.slice(cmdLine.length);
+
+  // Remove new prompt at end.
+  const index = ret.lastIndexOf('\n');
+  if (index >= 0) {
+    ret = ret.slice(0, index + 1);
+  } else {
+    ret = '';
+  }
+
+  return ret;
+}
+
+setup();
diff --git a/wasm/test/src/utils.ts b/wasm/test/src/utils.ts
new file mode 100644
index 0000000..07c6d63
--- /dev/null
+++ b/wasm/test/src/utils.ts
@@ -0,0 +1,28 @@
+import { IOutputCallback } from '@jupyterlite/cockle';
+
+/**
+ * Provides outputCallback to mock a terminal.
+ */
+export class MockTerminalOutput {
+  constructor() {}
+
+  callback: IOutputCallback = (output: string) => {
+    this._text = this._text + output.replace('\r\n', '\n');
+  };
+
+  clear() {
+    this._text = '';
+  }
+
+  get text(): string {
+    return this._text;
+  }
+
+  textAndClear(): string {
+    const ret = this.text;
+    this.clear();
+    return ret;
+  }
+
+  private _text: string = '';
+}
diff --git a/wasm/test/tsconfig.json b/wasm/test/tsconfig.json
new file mode 100644
index 0000000..097059d
--- /dev/null
+++ b/wasm/test/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "composite": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "incremental": true,
+    "lib": ["dom", "es2022", "webworker"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "preserveWatchOutput": true,
+    "resolveJsonModule": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "es2022",
+    "sourceMap": true
+  },
+  "include": ["src/*"]
+}
diff --git a/wasm/wasm-environment.yml b/wasm/wasm-environment.yml
new file mode 100644
index 0000000..a28c4dc
--- /dev/null
+++ b/wasm/wasm-environment.yml
@@ -0,0 +1,20 @@
+# Environment for building, deploying and testing WebAssembly build of git2cpp.
+name: git2cpp-wasm
+channels:
+  - conda-forge
+dependencies:
+  # To modify emscripten-forge recipe
+  - python
+  - pyyaml
+  # To build emscripten-forge recipe
+  - cmake
+  - micromamba
+  - rattler-build
+  # For JupyterLite deployment
+  - jupyter_server
+  - jupyterlite-terminal
+  # For cockle and JupyterLite deployments
+  - nodejs
+  # For testing
+  - pytest
+  - pytest-playwright