kodegen_tools_github 0.10.1

KODEGEN.ᴀɪ: Memory-efficient, Blazing-Fast, MCP tools for code generation agents.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! GitHub Multiple files push operation.

use crate::github::{error::GitHubError, util::spawn_task};
use crate::runtime::AsyncTask;
use octocrab::{
    Octocrab,
    models::repos::{Commit, Ref},
};
use std::collections::HashMap;
use std::sync::Arc;

/// Push multiple files in **one** commit (tree + commit + update-ref).
pub(crate) fn push_files(
    inner: Arc<Octocrab>,
    owner: impl Into<String>,
    repo: impl Into<String>,
    branch: impl Into<String>,
    files: HashMap<String, String>, // path -> base64-content
    message: impl Into<String>,
) -> AsyncTask<Result<Commit, GitHubError>> {
    let (owner, repo, branch, message) = (owner.into(), repo.into(), branch.into(), message.into());

    spawn_task(async move {
        // 1. Get latest commit SHA of branch
        let reference: Ref = inner
            .get(
                format!("repos/{owner}/{repo}/git/ref/heads/{branch}"),
                None::<&()>,
            )
            .await
            .map_err(GitHubError::from)?;

        let base_tree_sha = match reference.object {
            octocrab::models::repos::Object::Commit { sha, .. } => sha,
            octocrab::models::repos::Object::Tag { sha, .. } => sha,
            _ => return Err(GitHubError::Custom("Unexpected object type".into())),
        };

        // 2. Create a blob per file
        let mut tree_entries = Vec::new();
        for (path, content) in files {
            let blob: serde_json::Value = inner
                .post(
                    format!("repos/{owner}/{repo}/git/blobs"),
                    Some(&serde_json::json!({
                        "content": content,
                        "encoding": "base64"
                    })),
                )
                .await
                .map_err(GitHubError::from)?;

            tree_entries.push(serde_json::json!({
                "path": path,
                "mode": "100644",
                "type": "blob",
                "sha": blob["sha"]
            }));
        }

        // 3. Create tree
        let tree: serde_json::Value = inner
            .post(
                format!("repos/{owner}/{repo}/git/trees"),
                Some(&serde_json::json!({
                    "base_tree": base_tree_sha,
                    "tree": tree_entries
                })),
            )
            .await
            .map_err(GitHubError::from)?;

        // 4. Create commit
        let commit: Commit = inner
            .post(
                format!("repos/{owner}/{repo}/git/commits"),
                Some(&serde_json::json!({
                    "message": message,
                    "tree": tree["sha"],
                    "parents": [base_tree_sha]
                })),
            )
            .await
            .map_err(GitHubError::from)?;

        // 5. Update ref
        inner
            .patch::<(), _, _>(
                format!("repos/{owner}/{repo}/git/refs/heads/{branch}"),
                Some(&serde_json::json!({ "sha": commit.sha })),
            )
            .await
            .map_err(GitHubError::from)?;

        Ok(commit)
    })
}