tonin 0.6.0

Opinionated Rust microservice framework. Kubernetes-native, mesh-secured, MCP-by-default.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Clone and cache tonin templates directly from git repositories.
//!
//! No need for GitHub releases or tarballs — just clone at a specific tag.
//! Cached locally at ~/.tonin/templates/{repo-name}/{version}/

use anyhow::{anyhow, Result};
use std::path::PathBuf;
use std::process::Command;

const DEFAULT_REPO: &str = "https://github.com/Rushit/tonin-templates.git";

/// Get the cache directory for templates.
fn cache_dir(repo: &str, version: &str) -> Result<PathBuf> {
    let home = std::env::var("HOME").map_err(|_| anyhow!("HOME not set"))?;
    // Extract repo name from URL (e.g., "tonin-templates" or "tonin-templates-flat")
    let repo_name = repo
        .split('/')
        .last()
        .unwrap_or("tonin-templates")
        .trim_end_matches(".git");

    let cache_path = PathBuf::from(home)
        .join(".tonin")
        .join("templates")
        .join(repo_name)
        .join(version);

    Ok(cache_path)
}

/// Normalize git URL for consistency.
/// Accepts: https://github.com/Owner/repo.git, github.com/Owner/repo, Owner/repo
fn normalize_git_url(repo: &str) -> String {
    if repo.starts_with("https://") || repo.starts_with("git@") {
        repo.to_string()
    } else if repo.contains('/') {
        format!("https://github.com/{}.git", repo.trim_end_matches(".git"))
    } else {
        repo.to_string()
    }
}

/// Clone templates from a git repo and cache locally.
///
/// Repo: https://github.com/Owner/repo.git or Owner/repo
/// Version: git tag (e.g., "v0.4.0" or "latest")
pub fn load_templates(repo: Option<&str>, version: &str) -> Result<PathBuf> {
    let repo = repo.unwrap_or(DEFAULT_REPO);
    let repo_url = normalize_git_url(repo);
    let cache_path = cache_dir(&repo_url, version)?;

    // Already cached?
    if cache_path.exists() {
        eprintln!(
            "✓ Using cached templates from {}",
            cache_path.display()
        );
        return Ok(cache_path);
    }

    eprintln!("⬇ Cloning templates from {} @ {} ...", repo_url, version);

    // Create parent directory
    std::fs::create_dir_all(cache_path.parent().unwrap())
        .map_err(|e| anyhow!("Failed to create cache dir: {}", e))?;

    // Clone with depth=1 at specific tag
    let status = Command::new("git")
        .arg("clone")
        .arg("--depth=1")
        .arg("--branch")
        .arg(version)
        .arg(&repo_url)
        .arg(&cache_path)
        .status()
        .map_err(|e| anyhow!("Failed to run git clone: {}", e))?;

    if !status.success() {
        return Err(anyhow!(
            "Failed to clone templates from {} at tag {}",
            repo_url,
            version
        ));
    }

    // Remove .git to save space
    let git_dir = cache_path.join(".git");
    if git_dir.exists() {
        std::fs::remove_dir_all(&git_dir)
            .ok();
    }

    eprintln!(
        "✓ Templates cached to {}",
        cache_path.display()
    );
    Ok(cache_path)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_normalize_git_url() {
        assert_eq!(
            normalize_git_url("Owner/repo"),
            "https://github.com/Owner/repo.git"
        );
        assert_eq!(
            normalize_git_url("Owner/repo.git"),
            "https://github.com/Owner/repo.git"
        );
        assert_eq!(
            normalize_git_url("https://github.com/Owner/repo.git"),
            "https://github.com/Owner/repo.git"
        );
        assert_eq!(
            normalize_git_url("git@github.com:Owner/repo.git"),
            "git@github.com:Owner/repo.git"
        );
    }

    #[test]
    fn test_cache_dir() {
        let path = cache_dir("https://github.com/Rushit/tonin-templates-flat.git", "v0.4.0")
            .unwrap();
        assert!(path.to_string_lossy().contains("tonin-templates-flat"));
        assert!(path.to_string_lossy().contains("v0.4.0"));
    }
}