git.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/mcp/servers/git.h>
#include <entropic/mcp/tool_base.h>
#include <entropic/mcp/server_base.h>
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <array>
#include <cstdio>
#include <string>
 
static auto logger = entropic::log::get("mcp.git");
 
namespace entropic {
 
// ── shell helper ────────────────────────────────────────────────
 
static std::pair<std::string, int> run_git(
    const std::string& repo_dir,
    const std::string& git_args) {
 
    std::string full_cmd =
        "git -C " + repo_dir + " " + git_args + " 2>&1";
 
    FILE* pipe = popen(full_cmd.c_str(), "r");  // NOLINT
    if (pipe == nullptr) {
        return {"Failed to open git process", -1};
    }
 
    std::string output;
    std::array<char, 4096> buf{};
    while (fgets(buf.data(), buf.size(), pipe) != nullptr) {
        output += buf.data();
    }
 
    int status = pclose(pipe);  // NOLINT
    int exit_code = WEXITSTATUS(status);
    logger->info("Git: '{}' exit={}, {} chars",
                 git_args, exit_code, output.size());
    return {output, exit_code};
}
 
static ServerResponse make_git_response(
    const std::string& output, int exit_code) {
 
    nlohmann::json result;
    result["exit_code"] = exit_code;
    result["output"] = output;
    return {result.dump(), {}};
}
 
// ── GitStatusTool ───────────────────────────────────────────────
 
class GitStatusTool : public ToolBase {
public:
    GitStatusTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    MCPAccessLevel required_access_level() const override {
        return MCPAccessLevel::READ;
    }
 
    ServerResponse execute(const std::string& args_json) override {
        (void)args_json;
        auto [out, rc] = run_git(
            server_.repo_dir().string(), "status --short");
        logger->info("[git.status] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitDiffTool ─────────────────────────────────────────────────
 
class GitDiffTool : public ToolBase {
public:
    GitDiffTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    MCPAccessLevel required_access_level() const override {
        return MCPAccessLevel::READ;
    }
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        std::string cmd = "diff";
        if (args.value("staged", false)) {
            cmd += " --staged";
        }
        if (args.contains("file")) {
            cmd += " " + args["file"].get<std::string>();
        }
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.diff] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitLogTool ──────────────────────────────────────────────────
 
class GitLogTool : public ToolBase {
public:
    GitLogTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    MCPAccessLevel required_access_level() const override {
        return MCPAccessLevel::READ;
    }
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        int count = args.value("count", 10);
        std::string cmd = "log -" + std::to_string(count);
        if (args.value("oneline", false)) {
            cmd += " --oneline";
        }
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.log] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitCommitTool ───────────────────────────────────────────────
 
class GitCommitTool : public ToolBase {
public:
    GitCommitTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        auto repo = server_.repo_dir().string();
 
        if (args.value("add_all", false)) {
            auto [out, rc] = run_git(repo, "add -A");
            if (rc != 0) {
                logger->error("[git.commit] add -A failed: {}", out);
                return make_git_response(out, rc);
            }
        }
 
        std::string msg = args.at("message").get<std::string>();
        std::string cmd = "commit -m \"" + msg + "\"";
        auto [out, rc] = run_git(repo, cmd);
        logger->info("[git.commit] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitBranchTool ───────────────────────────────────────────────
 
class GitBranchTool : public ToolBase {
public:
    GitBranchTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        std::string cmd = "branch -a";
        if (args.contains("create")) {
            cmd = "checkout -b "
                + args["create"].get<std::string>();
        }
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.branch] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitCheckoutTool ─────────────────────────────────────────────
 
class GitCheckoutTool : public ToolBase {
public:
    GitCheckoutTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        std::string target = args.at("target").get<std::string>();
        std::string cmd = "checkout " + target;
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.checkout] target='{}' exit={}", target, rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitAddTool ──────────────────────────────────────────────────
 
class GitAddTool : public ToolBase {
public:
    GitAddTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        std::string files = args.at("files").get<std::string>();
        std::string cmd = "add " + files;
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.add] files='{}' exit={}", files, rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitResetTool ────────────────────────────────────────────────
 
class GitResetTool : public ToolBase {
public:
    GitResetTool(ToolDefinition def, GitServer& server)
        : ToolBase(std::move(def)), server_(server) {}
 
    ServerResponse execute(const std::string& args_json) override {
        auto args = nlohmann::json::parse(args_json);
        std::string cmd = "reset HEAD";
        if (args.contains("files")) {
            cmd += " " + args["files"].get<std::string>();
        }
        auto [out, rc] = run_git(server_.repo_dir().string(), cmd);
        logger->info("[git.reset] exit={}", rc);
        return make_git_response(out, rc);
    }
 
private:
    GitServer& server_;
};
 
// ── GitServer ───────────────────────────────────────────────────
 
GitServer::GitServer(
    const std::filesystem::path& repo_dir,
    const std::string& data_dir)
    : MCPServerBase("git")
    , repo_dir_(repo_dir) {
 
    create_git_tools(data_dir + "/tools");
    register_git_tools();
 
    logger->info("GitServer initialized: repo='{}'",
                 repo_dir_.string());
}
 
void GitServer::create_git_tools(const std::string& tools_dir) {
    status_ = std::make_unique<GitStatusTool>(
        load_tool_definition("status", "git", tools_dir), *this);
    diff_ = std::make_unique<GitDiffTool>(
        load_tool_definition("diff", "git", tools_dir), *this);
    log_ = std::make_unique<GitLogTool>(
        load_tool_definition("log", "git", tools_dir), *this);
    commit_ = std::make_unique<GitCommitTool>(
        load_tool_definition("commit", "git", tools_dir), *this);
    branch_ = std::make_unique<GitBranchTool>(
        load_tool_definition("branch", "git", tools_dir), *this);
    checkout_ = std::make_unique<GitCheckoutTool>(
        load_tool_definition("checkout", "git", tools_dir), *this);
    add_ = std::make_unique<GitAddTool>(
        load_tool_definition("add", "git", tools_dir), *this);
    reset_ = std::make_unique<GitResetTool>(
        load_tool_definition("reset", "git", tools_dir), *this);
}
 
void GitServer::register_git_tools() {
    register_tool(status_.get());
    register_tool(diff_.get());
    register_tool(log_.get());
    register_tool(commit_.get());
    register_tool(branch_.get());
    register_tool(checkout_.get());
    register_tool(add_.get());
    register_tool(reset_.get());
}
 
GitServer::~GitServer() = default;
 
bool GitServer::set_working_dir(const std::string& path) {
    repo_dir_ = path;
    logger->info("Repo directory set to: {}", path);
    return true;
}
 
const std::filesystem::path& GitServer::repo_dir() const {
    return repo_dir_;
}
 
} // namespace entropic