n_git.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifdef HAVE_LIBGIT2
 
/* libgit2 *_INIT macros trigger -Wmissing-field-initializers; suppress here */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
 
#include "nilorea/n_git.h"
#include "nilorea/n_log.h"
#include "nilorea/n_common.h"
 
#include <string.h>
#include <stdio.h>
 
static int _n_git_initialized = 0;
 
static void _n_git_ensure_init(void) {
    if (!_n_git_initialized) {
        git_libgit2_init();
        _n_git_initialized = 1;
    }
}
 
static void _n_git_log_error(const char* func_name) {
    const git_error* err = git_error_last();
    if (err) {
        n_log(LOG_ERR, "%s: %s", func_name, err->message);
    } else {
        n_log(LOG_ERR, "%s: unknown libgit2 error", func_name);
    }
}
 
static void _n_git_status_entry_destroy(void* ptr) {
    // cppcheck-suppress uselessAssignmentPtrArg -- FreeNoLog nulls local copy, intentional for destroy callback API
    FreeNoLog(ptr);
}
 
static void _n_git_commit_info_destroy(void* ptr) {
    // cppcheck-suppress uselessAssignmentPtrArg -- FreeNoLog nulls local copy, intentional for destroy callback API
    FreeNoLog(ptr);
}
 
static void _n_git_string_destroy(void* ptr) {
    // cppcheck-suppress uselessAssignmentPtrArg -- FreeNoLog nulls local copy, intentional for destroy callback API
    FreeNoLog(ptr);
}
 
static int _n_git_diff_print_cb(const git_diff_delta* delta, const git_diff_hunk* hunk, const git_diff_line* line, void* payload) {
    (void)delta;
    (void)hunk;
    N_STR** nstr = (N_STR**)payload;
 
    /* line->content is not null-terminated; copy it */
    if (line->content && line->content_len > 0) {
        char* tmp = NULL;
        Malloc(tmp, char, line->content_len + 2);
        if (tmp) {
            memcpy(tmp, line->content, line->content_len);
            tmp[line->content_len] = '\0';
            nstrprintf_cat(*nstr, "%c%s", line->origin, tmp);
            FreeNoLog(tmp);
        }
    }
    return 0;
}
 
N_GIT_REPO* n_git_open(const char* path) {
    __n_assert(path, return NULL);
 
    _n_git_ensure_init();
 
    N_GIT_REPO* ngit = NULL;
    Malloc(ngit, N_GIT_REPO, 1);
    __n_assert(ngit, return NULL);
 
    ngit->path = strdup(path);
    if (!ngit->path) {
        n_log(LOG_ERR, "n_git_open: strdup failed");
        FreeNoLog(ngit);
        return NULL;
    }
 
    int err = git_repository_open(&ngit->repo, path);
    if (err < 0) {
        _n_git_log_error("n_git_open");
        FreeNoLog(ngit->path);
        FreeNoLog(ngit);
        return NULL;
    }
 
    return ngit;
} /* n_git_open */
 
N_GIT_REPO* n_git_init(const char* path) {
    __n_assert(path, return NULL);
 
    _n_git_ensure_init();
 
    N_GIT_REPO* ngit = NULL;
    Malloc(ngit, N_GIT_REPO, 1);
    __n_assert(ngit, return NULL);
 
    ngit->path = strdup(path);
    if (!ngit->path) {
        n_log(LOG_ERR, "n_git_init: strdup failed");
        FreeNoLog(ngit);
        return NULL;
    }
 
    int err = git_repository_init(&ngit->repo, path, 0);
    if (err < 0) {
        _n_git_log_error("n_git_init");
        FreeNoLog(ngit->path);
        FreeNoLog(ngit);
        return NULL;
    }
 
    return ngit;
} /* n_git_init */
 
void n_git_close(N_GIT_REPO** repo) {
    __n_assert(repo, return);
    __n_assert(*repo, return);
 
    if ((*repo)->repo) {
        git_repository_free((*repo)->repo);
        (*repo)->repo = NULL;
    }
    FreeNoLog((*repo)->path);
    if ((*repo)->remote_auth) {
        FreeNoLog((*repo)->remote_auth->username);
        FreeNoLog((*repo)->remote_auth->password);
        FreeNoLog((*repo)->remote_auth->ssh_pubkey_path);
        FreeNoLog((*repo)->remote_auth->ssh_privkey_path);
        FreeNoLog((*repo)->remote_auth->ssh_passphrase);
        FreeNoLog((*repo)->remote_auth);
    }
    FreeNoLog(*repo);
} /* n_git_close */
 
LIST* n_git_status(N_GIT_REPO* repo) {
    __n_assert(repo, return NULL);
    __n_assert(repo->repo, return NULL);
 
    git_status_options opts = GIT_STATUS_OPTIONS_INIT;
    opts.show = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
    opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED | GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX;
 
    git_status_list* status_list = NULL;
    int err = git_status_list_new(&status_list, repo->repo, &opts);
    if (err < 0) {
        _n_git_log_error("n_git_status");
        return NULL;
    }
 
    LIST* list = new_generic_list(UNLIMITED_LIST_ITEMS);
    if (!list) {
        git_status_list_free(status_list);
        return NULL;
    }
 
    size_t count = git_status_list_entrycount(status_list);
    for (size_t i = 0; i < count; i++) {
        const git_status_entry* entry = git_status_byindex(status_list, i);
        if (!entry) continue;
 
        N_GIT_STATUS_ENTRY* se = NULL;
        Malloc(se, N_GIT_STATUS_ENTRY, 1);
        if (!se) continue;
 
        const char* fpath = NULL;
        if (entry->head_to_index && entry->head_to_index->new_file.path) {
            fpath = entry->head_to_index->new_file.path;
        } else if (entry->index_to_workdir && entry->index_to_workdir->new_file.path) {
            fpath = entry->index_to_workdir->new_file.path;
        } else if (entry->index_to_workdir && entry->index_to_workdir->old_file.path) {
            fpath = entry->index_to_workdir->old_file.path;
        }
 
        if (fpath) {
            snprintf(se->path, sizeof(se->path), "%s", fpath);
        }
 
        se->flags = 0;
 
        /* index (staged) flags */
        if (entry->status & GIT_STATUS_INDEX_NEW) {
            se->flags |= N_GIT_STATUS_NEW | N_GIT_STATUS_STAGED;
        }
        if (entry->status & GIT_STATUS_INDEX_MODIFIED) {
            se->flags |= N_GIT_STATUS_MODIFIED | N_GIT_STATUS_STAGED;
        }
        if (entry->status & GIT_STATUS_INDEX_DELETED) {
            se->flags |= N_GIT_STATUS_DELETED | N_GIT_STATUS_STAGED;
        }
 
        /* workdir (unstaged) flags */
        if (entry->status & GIT_STATUS_WT_NEW) {
            se->flags |= N_GIT_STATUS_NEW;
        }
        if (entry->status & GIT_STATUS_WT_MODIFIED) {
            se->flags |= N_GIT_STATUS_MODIFIED;
        }
        if (entry->status & GIT_STATUS_WT_DELETED) {
            se->flags |= N_GIT_STATUS_DELETED;
        }
 
        list_push(list, se, _n_git_status_entry_destroy);
    }
 
    git_status_list_free(status_list);
    return list;
} /* n_git_status */
 
int n_git_stage(N_GIT_REPO* repo, const char* filepath) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(filepath, return -1);
 
    git_index* index = NULL;
    int ret = -1;
 
    int err = git_repository_index(&index, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_stage");
        return -1;
    }
 
    err = git_index_add_bypath(index, filepath);
    if (err < 0) {
        _n_git_log_error("n_git_stage");
        goto cleanup;
    }
 
    err = git_index_write(index);
    if (err < 0) {
        _n_git_log_error("n_git_stage");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    git_index_free(index);
    return ret;
} /* n_git_stage */
 
int n_git_stage_all(N_GIT_REPO* repo) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
 
    git_index* index = NULL;
    int ret = -1;
 
    int err = git_repository_index(&index, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_stage_all");
        return -1;
    }
 
    err = git_index_add_all(index, NULL, GIT_INDEX_ADD_DEFAULT, NULL, NULL);
    if (err < 0) {
        _n_git_log_error("n_git_stage_all");
        goto cleanup;
    }
 
    err = git_index_write(index);
    if (err < 0) {
        _n_git_log_error("n_git_stage_all");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    git_index_free(index);
    return ret;
} /* n_git_stage_all */
 
int n_git_unstage(N_GIT_REPO* repo, const char* filepath) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(filepath, return -1);
 
    git_reference* head_ref = NULL;
    git_object* head_obj = NULL;
    int ret = -1;
 
    /* try to get HEAD; for initial commit there may be no HEAD */
    int err = git_repository_head(&head_ref, repo->repo);
    if (err == 0) {
        err = git_reference_peel(&head_obj, head_ref, GIT_OBJECT_COMMIT);
        if (err < 0) {
            _n_git_log_error("n_git_unstage");
            goto cleanup;
        }
    }
 
    git_strarray paths;
    char* path_str = (char*)filepath;
    paths.strings = &path_str;
    paths.count = 1;
 
    err = git_reset_default(repo->repo, head_obj, &paths);
    if (err < 0) {
        _n_git_log_error("n_git_unstage");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    if (head_obj) git_object_free(head_obj);
    if (head_ref) git_reference_free(head_ref);
    return ret;
} /* n_git_unstage */
 
int n_git_commit(N_GIT_REPO* repo, const char* message, const char* author_name, const char* author_email) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(message, return -1);
    __n_assert(author_name, return -1);
    __n_assert(author_email, return -1);
 
    git_index* index = NULL;
    git_oid tree_oid;
    git_oid commit_oid;
    git_tree* tree = NULL;
    git_signature* sig = NULL;
    git_commit* parent_commit = NULL;
    git_reference* head_ref = NULL;
    int ret = -1;
 
    int err = git_repository_index(&index, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_commit");
        return -1;
    }
 
    err = git_index_write_tree(&tree_oid, index);
    if (err < 0) {
        _n_git_log_error("n_git_commit");
        goto cleanup;
    }
 
    err = git_tree_lookup(&tree, repo->repo, &tree_oid);
    if (err < 0) {
        _n_git_log_error("n_git_commit");
        goto cleanup;
    }
 
    err = git_signature_now(&sig, author_name, author_email);
    if (err < 0) {
        _n_git_log_error("n_git_commit");
        goto cleanup;
    }
 
    /* try to get HEAD as parent; if no HEAD this is the initial commit */
    int have_parent = 0;
    err = git_repository_head(&head_ref, repo->repo);
    if (err == 0) {
        err = git_reference_peel((git_object**)&parent_commit, head_ref, GIT_OBJECT_COMMIT);
        if (err == 0) {
            have_parent = 1;
        }
    }
 
    if (have_parent) {
        const git_commit* parents[] = {parent_commit};
        err = git_commit_create(&commit_oid, repo->repo, "HEAD", sig, sig, "UTF-8", message, tree, 1, parents);
    } else {
        err = git_commit_create(&commit_oid, repo->repo, "HEAD", sig, sig, "UTF-8", message, tree, 0, NULL);
    }
 
    if (err < 0) {
        _n_git_log_error("n_git_commit");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    if (parent_commit) git_commit_free(parent_commit);
    if (head_ref) git_reference_free(head_ref);
    if (sig) git_signature_free(sig);
    if (tree) git_tree_free(tree);
    git_index_free(index);
    return ret;
} /* n_git_commit */
 
LIST* n_git_log(N_GIT_REPO* repo, size_t max_entries) {
    __n_assert(repo, return NULL);
    __n_assert(repo->repo, return NULL);
 
    git_revwalk* walker = NULL;
    int err = git_revwalk_new(&walker, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_log");
        return NULL;
    }
 
    git_revwalk_sorting(walker, GIT_SORT_TIME);
 
    err = git_revwalk_push_head(walker);
    if (err < 0) {
        _n_git_log_error("n_git_log");
        git_revwalk_free(walker);
        return NULL;
    }
 
    LIST* list = new_generic_list(UNLIMITED_LIST_ITEMS);
    if (!list) {
        git_revwalk_free(walker);
        return NULL;
    }
 
    git_oid oid;
    size_t count = 0;
    while (count < max_entries && git_revwalk_next(&oid, walker) == 0) {
        git_commit* commit = NULL;
        err = git_commit_lookup(&commit, repo->repo, &oid);
        if (err < 0) {
            _n_git_log_error("n_git_log");
            continue;
        }
 
        N_GIT_COMMIT_INFO* info = NULL;
        Malloc(info, N_GIT_COMMIT_INFO, 1);
        if (!info) {
            git_commit_free(commit);
            continue;
        }
 
        /* hash */
        char hex[GIT_OID_SHA1_HEXSIZE + 1];
        git_oid_tostr(hex, sizeof(hex), &oid);
        snprintf(info->hash, sizeof(info->hash), "%s", hex);
        snprintf(info->short_hash, sizeof(info->short_hash), "%.8s", hex);
 
        /* message */
        const char* msg = git_commit_message(commit);
        if (msg) {
            snprintf(info->message, sizeof(info->message), "%s", msg);
        }
 
        /* author */
        const git_signature* author = git_commit_author(commit);
        if (author) {
            snprintf(info->author, sizeof(info->author), "%s <%s>", author->name ? author->name : "", author->email ? author->email : "");
            info->timestamp = (int64_t)author->when.time;
        }
 
        list_push(list, info, _n_git_commit_info_destroy);
        git_commit_free(commit);
        count++;
    }
 
    git_revwalk_free(walker);
    return list;
} /* n_git_log */
 
N_STR* n_git_diff_workdir(N_GIT_REPO* repo) {
    __n_assert(repo, return NULL);
    __n_assert(repo->repo, return NULL);
 
    git_diff* diff = NULL;
    int err = git_diff_index_to_workdir(&diff, repo->repo, NULL, NULL);
    if (err < 0) {
        _n_git_log_error("n_git_diff_workdir");
        return NULL;
    }
 
    N_STR* result = new_nstr(256);
    if (!result) {
        git_diff_free(diff);
        return NULL;
    }
 
    git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, _n_git_diff_print_cb, &result);
 
    git_diff_free(diff);
    return result;
} /* n_git_diff_workdir */
 
N_STR* n_git_diff_commits(N_GIT_REPO* repo, const char* hash_a, const char* hash_b) {
    __n_assert(repo, return NULL);
    __n_assert(repo->repo, return NULL);
    __n_assert(hash_a, return NULL);
    __n_assert(hash_b, return NULL);
 
    git_object* obj_a = NULL;
    git_object* obj_b = NULL;
    git_commit* commit_a = NULL;
    git_commit* commit_b = NULL;
    git_tree* tree_a = NULL;
    git_tree* tree_b = NULL;
    git_diff* diff = NULL;
    N_STR* result = NULL;
    int err = 0;
 
    err = git_revparse_single(&obj_a, repo->repo, hash_a);
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_revparse_single(&obj_b, repo->repo, hash_b);
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_commit_lookup(&commit_a, repo->repo, git_object_id(obj_a));
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_commit_lookup(&commit_b, repo->repo, git_object_id(obj_b));
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_commit_tree(&tree_a, commit_a);
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_commit_tree(&tree_b, commit_b);
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    err = git_diff_tree_to_tree(&diff, repo->repo, tree_a, tree_b, NULL);
    if (err < 0) {
        _n_git_log_error("n_git_diff_commits");
        goto cleanup;
    }
 
    result = new_nstr(256);
    if (!result) {
        goto cleanup;
    }
 
    git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, _n_git_diff_print_cb, &result);
 
cleanup:
    if (diff) git_diff_free(diff);
    if (tree_b) git_tree_free(tree_b);
    if (tree_a) git_tree_free(tree_a);
    if (commit_b) git_commit_free(commit_b);
    if (commit_a) git_commit_free(commit_a);
    if (obj_b) git_object_free(obj_b);
    if (obj_a) git_object_free(obj_a);
    return result;
} /* n_git_diff_commits */
 
int n_git_checkout_path(N_GIT_REPO* repo, const char* filepath) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(filepath, return -1);
 
    char* path_str = (char*)filepath;
    git_strarray paths;
    paths.strings = &path_str;
    paths.count = 1;
 
    git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
    opts.checkout_strategy = GIT_CHECKOUT_FORCE;
    opts.paths = paths;
 
    int err = git_checkout_head(repo->repo, &opts);
    if (err < 0) {
        _n_git_log_error("n_git_checkout_path");
        return -1;
    }
 
    return 0;
} /* n_git_checkout_path */
 
int n_git_checkout_commit(N_GIT_REPO* repo, const char* hash) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(hash, return -1);
 
    git_object* obj = NULL;
    int ret = -1;
 
    int err = git_revparse_single(&obj, repo->repo, hash);
    if (err < 0) {
        _n_git_log_error("n_git_checkout_commit");
        return -1;
    }
 
    git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
    opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
    err = git_checkout_tree(repo->repo, obj, &opts);
    if (err < 0) {
        _n_git_log_error("n_git_checkout_commit");
        goto cleanup;
    }
 
    err = git_repository_set_head_detached(repo->repo, git_object_id(obj));
    if (err < 0) {
        _n_git_log_error("n_git_checkout_commit");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    git_object_free(obj);
    return ret;
} /* n_git_checkout_commit */
 
LIST* n_git_list_branches(N_GIT_REPO* repo) {
    __n_assert(repo, return NULL);
    __n_assert(repo->repo, return NULL);
 
    git_branch_iterator* iter = NULL;
    int err = git_branch_iterator_new(&iter, repo->repo, GIT_BRANCH_LOCAL);
    if (err < 0) {
        _n_git_log_error("n_git_list_branches");
        return NULL;
    }
 
    LIST* list = new_generic_list(UNLIMITED_LIST_ITEMS);
    if (!list) {
        git_branch_iterator_free(iter);
        return NULL;
    }
 
    git_reference* ref = NULL;
    git_branch_t type;
    while (git_branch_next(&ref, &type, iter) == 0) {
        const char* name = NULL;
        err = git_branch_name(&name, ref);
        if (err == 0 && name) {
            char* dup = strdup(name);
            if (dup) {
                list_push(list, dup, _n_git_string_destroy);
            }
        }
        git_reference_free(ref);
    }
 
    git_branch_iterator_free(iter);
    return list;
} /* n_git_list_branches */
 
int n_git_create_branch(N_GIT_REPO* repo, const char* branch_name) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(branch_name, return -1);
 
    git_reference* head_ref = NULL;
    git_commit* head_commit = NULL;
    git_reference* new_branch = NULL;
    int ret = -1;
 
    int err = git_repository_head(&head_ref, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_create_branch");
        return -1;
    }
 
    err = git_reference_peel((git_object**)&head_commit, head_ref, GIT_OBJECT_COMMIT);
    if (err < 0) {
        _n_git_log_error("n_git_create_branch");
        goto cleanup;
    }
 
    err = git_branch_create(&new_branch, repo->repo, branch_name, head_commit, 0);
    if (err < 0) {
        _n_git_log_error("n_git_create_branch");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    if (new_branch) git_reference_free(new_branch);
    if (head_commit) git_commit_free(head_commit);
    git_reference_free(head_ref);
    return ret;
} /* n_git_create_branch */
 
int n_git_switch_branch(N_GIT_REPO* repo, const char* branch_name) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(branch_name, return -1);
 
    git_reference* branch_ref = NULL;
    int ret = -1;
 
    int err = git_branch_lookup(&branch_ref, repo->repo, branch_name, GIT_BRANCH_LOCAL);
    if (err < 0) {
        _n_git_log_error("n_git_switch_branch");
        return -1;
    }
 
    char refname[512];
    snprintf(refname, sizeof(refname), "refs/heads/%s", branch_name);
 
    err = git_repository_set_head(repo->repo, refname);
    if (err < 0) {
        _n_git_log_error("n_git_switch_branch");
        goto cleanup;
    }
 
    git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
    opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
    err = git_checkout_head(repo->repo, &opts);
    if (err < 0) {
        _n_git_log_error("n_git_switch_branch");
        goto cleanup;
    }
 
    ret = 0;
 
cleanup:
    git_reference_free(branch_ref);
    return ret;
} /* n_git_switch_branch */
 
int n_git_current_branch(N_GIT_REPO* repo, char* out, size_t out_size) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(out, return -1);
 
    git_reference* head_ref = NULL;
 
    int err = git_repository_head(&head_ref, repo->repo);
    if (err < 0) {
        _n_git_log_error("n_git_current_branch");
        return -1;
    }
 
    const char* shorthand = git_reference_shorthand(head_ref);
    if (shorthand) {
        snprintf(out, out_size, "%s", shorthand);
    } else {
        out[0] = '\0';
    }
 
    git_reference_free(head_ref);
    return 0;
} /* n_git_current_branch */
 
int n_git_delete_branch(N_GIT_REPO* repo, const char* branch_name) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(branch_name, return -1);
 
    git_reference* branch_ref = NULL;
 
    int err = git_branch_lookup(&branch_ref, repo->repo, branch_name, GIT_BRANCH_LOCAL);
    if (err < 0) {
        _n_git_log_error("n_git_delete_branch");
        return -1;
    }
 
    err = git_branch_delete(branch_ref);
    git_reference_free(branch_ref);
 
    if (err < 0) {
        _n_git_log_error("n_git_delete_branch");
        return -1;
    }
 
    return 0;
} /* n_git_delete_branch */
 
/* ========================================================================
 *  REMOTE OPERATIONS: auth, push, pull
 * ======================================================================== */
 
static int _n_git_cred_cb(git_credential** out, const char* url, const char* username_from_url, unsigned int allowed_types, void* payload) {
    (void)url;
    N_GIT_REMOTE_AUTH* auth = (N_GIT_REMOTE_AUTH*)payload;
    if (!auth) return GIT_PASSTHROUGH;
 
    switch (auth->type) {
        case N_GIT_AUTH_TOKEN:
            if ((allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) &&
                auth->password) {
                const char* user = auth->username ? auth->username : "x-access-token";
                return git_credential_userpass_plaintext_new(out, user, auth->password);
            }
            break;
 
        case N_GIT_AUTH_BASIC:
            if ((allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT) &&
                auth->username && auth->password) {
                return git_credential_userpass_plaintext_new(out, auth->username, auth->password);
            }
            break;
 
        case N_GIT_AUTH_SSH:
            if ((allowed_types & GIT_CREDENTIAL_SSH_KEY) &&
                auth->ssh_privkey_path) {
                const char* user = auth->username ? auth->username : (username_from_url ? username_from_url : "git");
                return git_credential_ssh_key_new(out, user,
                                                  auth->ssh_pubkey_path, auth->ssh_privkey_path,
                                                  auth->ssh_passphrase ? auth->ssh_passphrase : "");
            }
            /* Try SSH agent if key auth not available */
            if (allowed_types & GIT_CREDENTIAL_SSH_KEY) {
                const char* user = auth->username ? auth->username : (username_from_url ? username_from_url : "git");
                return git_credential_ssh_key_from_agent(out, user);
            }
            break;
 
        default:
            break;
    }
 
    return GIT_PASSTHROUGH;
} /* _n_git_cred_cb */
 
int n_git_set_remote_auth(N_GIT_REPO* repo, const N_GIT_REMOTE_AUTH* auth) {
    __n_assert(repo, return -1);
    __n_assert(auth, return -1);
 
    /* Free existing auth */
    if (repo->remote_auth) {
        FreeNoLog(repo->remote_auth->username);
        FreeNoLog(repo->remote_auth->password);
        FreeNoLog(repo->remote_auth->ssh_pubkey_path);
        FreeNoLog(repo->remote_auth->ssh_privkey_path);
        FreeNoLog(repo->remote_auth->ssh_passphrase);
        FreeNoLog(repo->remote_auth);
    }
 
    N_GIT_REMOTE_AUTH* a = NULL;
    Malloc(a, N_GIT_REMOTE_AUTH, 1);
    __n_assert(a, return -1);
    memset(a, 0, sizeof(*a));
 
    a->type = auth->type;
    if (auth->username) a->username = strdup(auth->username);
    if (auth->password) a->password = strdup(auth->password);
    if (auth->ssh_pubkey_path) a->ssh_pubkey_path = strdup(auth->ssh_pubkey_path);
    if (auth->ssh_privkey_path) a->ssh_privkey_path = strdup(auth->ssh_privkey_path);
    if (auth->ssh_passphrase) a->ssh_passphrase = strdup(auth->ssh_passphrase);
 
    repo->remote_auth = a;
    return 0;
} /* n_git_set_remote_auth */
 
int n_git_remote_set_url(N_GIT_REPO* repo, const char* url) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
    __n_assert(url, return -1);
 
    _n_git_ensure_init();
 
    git_remote* remote = NULL;
    int err = git_remote_lookup(&remote, repo->repo, "origin");
    if (err == 0) {
        /* Remote exists — update URL if different */
        const char* current_url = git_remote_url(remote);
        if (!current_url || strcmp(current_url, url) != 0) {
            git_remote_free(remote);
            err = git_remote_set_url(repo->repo, "origin", url);
            if (err < 0) {
                _n_git_log_error("n_git_remote_set_url: set_url");
                return -1;
            }
        } else {
            git_remote_free(remote);
        }
    } else {
        /* Remote does not exist — create it */
        err = git_remote_create(&remote, repo->repo, "origin", url);
        if (err < 0) {
            _n_git_log_error("n_git_remote_set_url: create");
            return -1;
        }
        git_remote_free(remote);
    }
 
    return 0;
} /* n_git_remote_set_url */
 
int n_git_push(N_GIT_REPO* repo) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
 
    _n_git_ensure_init();
 
    /* Get current branch name */
    char branch[128];
    if (n_git_current_branch(repo, branch, sizeof(branch)) != 0) {
        n_log(LOG_ERR, "n_git_push: cannot determine current branch");
        return -1;
    }
 
    /* Build refspec: refs/heads/branch:refs/heads/branch */
    char refspec[300];
    snprintf(refspec, sizeof(refspec), "refs/heads/%s:refs/heads/%s",
             branch, branch);
 
    git_remote* remote = NULL;
    int err = git_remote_lookup(&remote, repo->repo, "origin");
    if (err < 0) {
        _n_git_log_error("n_git_push: remote lookup");
        return -1;
    }
 
    /* Set up push options with credential callback */
    git_push_options opts = GIT_PUSH_OPTIONS_INIT;
    if (repo->remote_auth) {
        opts.callbacks.credentials = _n_git_cred_cb;
        opts.callbacks.payload = repo->remote_auth;
    }
 
    const char* refspecs[] = {refspec};
    git_strarray refspec_arr = {(char**)refspecs, 1};
 
    err = git_remote_push(remote, &refspec_arr, &opts);
    git_remote_free(remote);
 
    if (err < 0) {
        _n_git_log_error("n_git_push");
        return -1;
    }
 
    n_log(LOG_INFO, "n_git_push: pushed %s to origin", branch);
    return 0;
} /* n_git_push */
 
int n_git_pull(N_GIT_REPO* repo) {
    __n_assert(repo, return -1);
    __n_assert(repo->repo, return -1);
 
    _n_git_ensure_init();
 
    /* Fetch from origin */
    git_remote* remote = NULL;
    int err = git_remote_lookup(&remote, repo->repo, "origin");
    if (err < 0) {
        _n_git_log_error("n_git_pull: remote lookup");
        return -1;
    }
 
    git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
    if (repo->remote_auth) {
        fetch_opts.callbacks.credentials = _n_git_cred_cb;
        fetch_opts.callbacks.payload = repo->remote_auth;
    }
 
    err = git_remote_fetch(remote, NULL, &fetch_opts, "pull");
    git_remote_free(remote);
 
    if (err < 0) {
        _n_git_log_error("n_git_pull: fetch");
        return -1;
    }
 
    /* Get current branch name */
    char branch[128];
    if (n_git_current_branch(repo, branch, sizeof(branch)) != 0) {
        n_log(LOG_ERR, "n_git_pull: cannot determine current branch");
        return -1;
    }
 
    /* Look up the remote tracking ref: refs/remotes/origin/<branch> */
    char remote_ref[300];
    snprintf(remote_ref, sizeof(remote_ref), "refs/remotes/origin/%s", branch);
 
    git_oid remote_oid;
    err = git_reference_name_to_id(&remote_oid, repo->repo, remote_ref);
    if (err < 0) {
        _n_git_log_error("n_git_pull: remote ref lookup");
        return -1;
    }
 
    /* Get HEAD commit */
    git_oid local_oid;
    err = git_reference_name_to_id(&local_oid, repo->repo, "HEAD");
    if (err < 0) {
        _n_git_log_error("n_git_pull: HEAD lookup");
        return -1;
    }
 
    /* Check if already up to date */
    if (git_oid_equal(&local_oid, &remote_oid)) {
        n_log(LOG_INFO, "n_git_pull: already up to date");
        return 0;
    }
 
    /* Check if fast-forward is possible */
    git_annotated_commit* remote_commit = NULL;
    err = git_annotated_commit_lookup(&remote_commit, repo->repo, &remote_oid);
    if (err < 0) {
        _n_git_log_error("n_git_pull: annotated commit lookup");
        return -1;
    }
 
    git_merge_analysis_t analysis;
    git_merge_preference_t preference;
    const git_annotated_commit* their_heads[] = {remote_commit};
    err = git_merge_analysis(&analysis, &preference, repo->repo, their_heads, 1);
    if (err < 0) {
        git_annotated_commit_free(remote_commit);
        _n_git_log_error("n_git_pull: merge analysis");
        return -1;
    }
 
    if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE) {
        git_annotated_commit_free(remote_commit);
        n_log(LOG_INFO, "n_git_pull: already up to date");
        return 0;
    }
 
    if (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD) {
        /* Fast-forward: move HEAD to remote commit */
        git_reference* head_ref = NULL;
        err = git_repository_head(&head_ref, repo->repo);
        if (err < 0) {
            git_annotated_commit_free(remote_commit);
            _n_git_log_error("n_git_pull: get HEAD ref");
            return -1;
        }
 
        git_reference* new_ref = NULL;
        err = git_reference_set_target(&new_ref, head_ref, &remote_oid, "pull: fast-forward");
        git_reference_free(head_ref);
        if (err < 0) {
            git_annotated_commit_free(remote_commit);
            _n_git_log_error("n_git_pull: set target");
            return -1;
        }
        git_reference_free(new_ref);
 
        /* Checkout the new HEAD */
        git_object* target = NULL;
        git_object_lookup(&target, repo->repo, &remote_oid, GIT_OBJECT_COMMIT);
        if (target) {
            git_checkout_options co_opts = GIT_CHECKOUT_OPTIONS_INIT;
            co_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
            git_checkout_tree(repo->repo, target, &co_opts);
            git_object_free(target);
        }
 
        git_annotated_commit_free(remote_commit);
        n_log(LOG_INFO, "n_git_pull: fast-forwarded %s", branch);
        return 0;
    }
 
    /* Not a fast-forward — we don't handle merge conflicts */
    git_annotated_commit_free(remote_commit);
    n_log(LOG_ERR, "n_git_pull: cannot fast-forward, manual merge required");
    return -1;
} /* n_git_pull */
 
#pragma GCC diagnostic pop
 
#endif /* HAVE_LIBGIT2 */