use crate::config::get_config;
use crate::executors::{RequestConfig, execute};
use crate::executors::types::{Skill, SkillParameter};
use anyhow::Result;
use serde_json::{Value, json};
use std::collections::HashMap;
struct GitHubApi;
impl GitHubApi {
fn build_url(endpoint: &str) -> String {
let config = get_config();
format!(
"{}/{}",
config.github_api_url.trim_end_matches('/'),
endpoint
)
}
fn build_headers() -> HashMap<String, String> {
let config = get_config();
let mut headers = HashMap::new();
headers.insert(
"Accept".to_string(),
"application/vnd.github.v3+json".to_string(),
);
headers.insert(
"Authorization".to_string(),
format!("Bearer {}", config.github_token),
);
headers.insert("User-Agent".to_string(), "Hippox-Engine".to_string());
headers
}
async fn get(endpoint: &str) -> Result<String> {
let config = get_config();
let req_config = RequestConfig {
url: Self::build_url(endpoint),
method: "GET".to_string(),
headers: Some(Self::build_headers()),
body: None,
timeout_secs: Some(config.github_timeout),
};
let response = execute(&req_config).await?;
if response.is_success {
Ok(response.body)
} else {
anyhow::bail!("GitHub API error: {}", response.body)
}
}
async fn post(endpoint: &str, body: &str) -> Result<String> {
let config = get_config();
let req_config = RequestConfig {
url: Self::build_url(endpoint),
method: "POST".to_string(),
headers: Some(Self::build_headers()),
body: Some(body.to_string()),
timeout_secs: Some(config.github_timeout),
};
let response = execute(&req_config).await?;
if response.is_success {
Ok(response.body)
} else {
anyhow::bail!("GitHub API error: {}", response.body)
}
}
async fn put(endpoint: &str, body: Option<&str>) -> Result<String> {
let config = get_config();
let req_config = RequestConfig {
url: Self::build_url(endpoint),
method: "PUT".to_string(),
headers: Some(Self::build_headers()),
body: body.map(|s| s.to_string()),
timeout_secs: Some(config.github_timeout),
};
let response = execute(&req_config).await?;
if response.is_success {
Ok(response.body)
} else {
anyhow::bail!("GitHub API error: {}", response.body)
}
}
async fn delete(endpoint: &str) -> Result<String> {
let config = get_config();
let req_config = RequestConfig {
url: Self::build_url(endpoint),
method: "DELETE".to_string(),
headers: Some(Self::build_headers()),
body: None,
timeout_secs: Some(config.github_timeout),
};
let response = execute(&req_config).await?;
if response.is_success {
Ok(response.body)
} else {
anyhow::bail!("GitHub API error: {}", response.body)
}
}
}
#[derive(Debug)]
pub struct GithubGetRepo;
#[async_trait::async_trait]
impl Skill for GithubGetRepo {
fn name(&self) -> &str {
"github_get_repo"
}
fn description(&self) -> &str {
"Get information about a GitHub repository"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to get repository details like stars, forks, description"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "owner".to_string(),
param_type: "string".to_string(),
description: "Repository owner (username or organization)".to_string(),
required: true,
default: None,
example: Some(Value::String("rust-lang".to_string())),
enum_values: None,
},
SkillParameter {
name: "repo".to_string(),
param_type: "string".to_string(),
description: "Repository name".to_string(),
required: true,
default: None,
example: Some(Value::String("rust".to_string())),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_get_repo",
"parameters": {
"owner": "rust-lang",
"repo": "rust"
}
})
}
fn example_output(&self) -> String {
r#"{"name": "rust", "full_name": "rust-lang/rust", "description": "Empowering everyone...", "stargazers_count": 85000, "forks_count": 11000}"#.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let owner = parameters
.get("owner")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: owner"))?;
let repo = parameters
.get("repo")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: repo"))?;
let endpoint = format!("repos/{}/{}", owner, repo);
GitHubApi::get(&endpoint).await
}
}
#[derive(Debug)]
pub struct GithubCreateIssue;
#[async_trait::async_trait]
impl Skill for GithubCreateIssue {
fn name(&self) -> &str {
"github_create_issue"
}
fn description(&self) -> &str {
"Create an issue in a GitHub repository"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to report a bug or request a feature"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "owner".to_string(),
param_type: "string".to_string(),
description: "Repository owner".to_string(),
required: true,
default: None,
example: Some(Value::String("rust-lang".to_string())),
enum_values: None,
},
SkillParameter {
name: "repo".to_string(),
param_type: "string".to_string(),
description: "Repository name".to_string(),
required: true,
default: None,
example: Some(Value::String("rust".to_string())),
enum_values: None,
},
SkillParameter {
name: "title".to_string(),
param_type: "string".to_string(),
description: "Issue title".to_string(),
required: true,
default: None,
example: Some(Value::String("Bug: compilation error".to_string())),
enum_values: None,
},
SkillParameter {
name: "body".to_string(),
param_type: "string".to_string(),
description: "Issue body/description".to_string(),
required: false,
default: None,
example: Some(Value::String("When compiling with nightly...".to_string())),
enum_values: None,
},
SkillParameter {
name: "labels".to_string(),
param_type: "array".to_string(),
description: "Labels to apply".to_string(),
required: false,
default: Some(Value::Array(vec![])),
example: Some(json!(["bug", "help-wanted"])),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_create_issue",
"parameters": {
"owner": "rust-lang",
"repo": "rust",
"title": "Bug: compilation error",
"body": "When compiling with nightly...",
"labels": ["bug"]
}
})
}
fn example_output(&self) -> String {
r#"{"number": 12345, "html_url": "https://github.com/rust-lang/rust/issues/12345"}"#
.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let owner = parameters
.get("owner")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: owner"))?;
let repo = parameters
.get("repo")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: repo"))?;
let title = parameters
.get("title")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: title"))?;
let mut body = json!({
"title": title,
});
if let Some(b) = parameters.get("body").and_then(|v| v.as_str()) {
body["body"] = json!(b);
}
if let Some(labels) = parameters.get("labels").and_then(|v| v.as_array()) {
let label_strings: Vec<String> = labels
.iter()
.filter_map(|l| l.as_str())
.map(|s| s.to_string())
.collect();
body["labels"] = json!(label_strings);
}
let endpoint = format!("repos/{}/{}/issues", owner, repo);
GitHubApi::post(&endpoint, &body.to_string()).await
}
}
#[derive(Debug)]
pub struct GithubListIssues;
#[async_trait::async_trait]
impl Skill for GithubListIssues {
fn name(&self) -> &str {
"github_list_issues"
}
fn description(&self) -> &str {
"List issues from a GitHub repository"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to see existing issues"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "owner".to_string(),
param_type: "string".to_string(),
description: "Repository owner".to_string(),
required: true,
default: None,
example: Some(Value::String("rust-lang".to_string())),
enum_values: None,
},
SkillParameter {
name: "repo".to_string(),
param_type: "string".to_string(),
description: "Repository name".to_string(),
required: true,
default: None,
example: Some(Value::String("rust".to_string())),
enum_values: None,
},
SkillParameter {
name: "state".to_string(),
param_type: "string".to_string(),
description: "Issue state (open, closed, all)".to_string(),
required: false,
default: Some(Value::String("open".to_string())),
example: Some(Value::String("open".to_string())),
enum_values: Some(vec![
"open".to_string(),
"closed".to_string(),
"all".to_string(),
]),
},
SkillParameter {
name: "limit".to_string(),
param_type: "integer".to_string(),
description: "Maximum number of issues to return".to_string(),
required: false,
default: Some(Value::Number(30.into())),
example: Some(Value::Number(10.into())),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_list_issues",
"parameters": {
"owner": "rust-lang",
"repo": "rust",
"state": "open",
"limit": 10
}
})
}
fn example_output(&self) -> String {
r#"[{"number": 12345, "title": "Bug report", "state": "open"}]"#.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let owner = parameters
.get("owner")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: owner"))?;
let repo = parameters
.get("repo")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: repo"))?;
let state = parameters
.get("state")
.and_then(|v| v.as_str())
.unwrap_or("open");
let limit = parameters
.get("limit")
.and_then(|v| v.as_u64())
.unwrap_or(30);
let endpoint = format!(
"repos/{}/{}/issues?state={}&per_page={}",
owner, repo, state, limit
);
GitHubApi::get(&endpoint).await
}
}
#[derive(Debug)]
pub struct GithubStarRepo;
#[async_trait::async_trait]
impl Skill for GithubStarRepo {
fn name(&self) -> &str {
"github_star_repo"
}
fn description(&self) -> &str {
"Star a GitHub repository"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user wants to star/favorite a repository"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "owner".to_string(),
param_type: "string".to_string(),
description: "Repository owner".to_string(),
required: true,
default: None,
example: Some(Value::String("rust-lang".to_string())),
enum_values: None,
},
SkillParameter {
name: "repo".to_string(),
param_type: "string".to_string(),
description: "Repository name".to_string(),
required: true,
default: None,
example: Some(Value::String("rust".to_string())),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_star_repo",
"parameters": {
"owner": "rust-lang",
"repo": "rust"
}
})
}
fn example_output(&self) -> String {
"Successfully starred rust-lang/rust".to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let owner = parameters
.get("owner")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: owner"))?;
let repo = parameters
.get("repo")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: repo"))?;
let endpoint = format!("user/starred/{}/{}", owner, repo);
GitHubApi::put(&endpoint, None).await?;
Ok(format!("Successfully starred {}/{}", owner, repo))
}
}
#[derive(Debug)]
pub struct GithubSearchRepos;
#[async_trait::async_trait]
impl Skill for GithubSearchRepos {
fn name(&self) -> &str {
"github_search_repos"
}
fn description(&self) -> &str {
"Search GitHub repositories by query"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to find repositories"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "query".to_string(),
param_type: "string".to_string(),
description: "Search query (e.g., 'rust language:rust')".to_string(),
required: true,
default: None,
example: Some(Value::String("rust language:rust".to_string())),
enum_values: None,
},
SkillParameter {
name: "limit".to_string(),
param_type: "integer".to_string(),
description: "Maximum number of results".to_string(),
required: false,
default: Some(Value::Number(10.into())),
example: Some(Value::Number(5.into())),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_search_repos",
"parameters": {
"query": "rust language:rust",
"limit": 5
}
})
}
fn example_output(&self) -> String {
r#"{"total_count": 12345, "items": [{"full_name": "rust-lang/rust", "description": "..."}]}"#.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let query = parameters
.get("query")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: query"))?;
let limit = parameters
.get("limit")
.and_then(|v| v.as_u64())
.unwrap_or(10);
let encoded_query = urlencoding::encode(query);
let endpoint = format!("search/repositories?q={}&per_page={}", encoded_query, limit);
GitHubApi::get(&endpoint).await
}
}
#[derive(Debug)]
pub struct GithubGetUser;
#[async_trait::async_trait]
impl Skill for GithubGetUser {
fn name(&self) -> &str {
"github_get_user"
}
fn description(&self) -> &str {
"Get GitHub user information"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to get profile info of a GitHub user"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![SkillParameter {
name: "username".to_string(),
param_type: "string".to_string(),
description: "GitHub username".to_string(),
required: true,
default: None,
example: Some(Value::String("octocat".to_string())),
enum_values: None,
}]
}
fn example_call(&self) -> Value {
json!({
"action": "github_get_user",
"parameters": {
"username": "octocat"
}
})
}
fn example_output(&self) -> String {
r#"{"login": "octocat", "name": "The Octocat", "public_repos": 8}"#.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let username = parameters
.get("username")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: username"))?;
let endpoint = format!("users/{}", username);
GitHubApi::get(&endpoint).await
}
}
#[derive(Debug)]
pub struct GithubListPRs;
#[async_trait::async_trait]
impl Skill for GithubListPRs {
fn name(&self) -> &str {
"github_list_prs"
}
fn description(&self) -> &str {
"List pull requests from a GitHub repository"
}
fn usage_hint(&self) -> &str {
"Use this skill when the user needs to see open pull requests"
}
fn parameters(&self) -> Vec<SkillParameter> {
vec![
SkillParameter {
name: "owner".to_string(),
param_type: "string".to_string(),
description: "Repository owner".to_string(),
required: true,
default: None,
example: Some(Value::String("rust-lang".to_string())),
enum_values: None,
},
SkillParameter {
name: "repo".to_string(),
param_type: "string".to_string(),
description: "Repository name".to_string(),
required: true,
default: None,
example: Some(Value::String("rust".to_string())),
enum_values: None,
},
SkillParameter {
name: "state".to_string(),
param_type: "string".to_string(),
description: "PR state (open, closed, all)".to_string(),
required: false,
default: Some(Value::String("open".to_string())),
example: Some(Value::String("open".to_string())),
enum_values: Some(vec![
"open".to_string(),
"closed".to_string(),
"all".to_string(),
]),
},
SkillParameter {
name: "limit".to_string(),
param_type: "integer".to_string(),
description: "Maximum number of PRs to return".to_string(),
required: false,
default: Some(Value::Number(30.into())),
example: Some(Value::Number(10.into())),
enum_values: None,
},
]
}
fn example_call(&self) -> Value {
json!({
"action": "github_list_prs",
"parameters": {
"owner": "rust-lang",
"repo": "rust",
"state": "open",
"limit": 10
}
})
}
fn example_output(&self) -> String {
r#"[{"number": 123, "title": "Add feature", "user": {"login": "contributor"}}]"#.to_string()
}
fn category(&self) -> &str {
"github"
}
async fn execute(&self, parameters: &HashMap<String, Value>) -> Result<String> {
let owner = parameters
.get("owner")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: owner"))?;
let repo = parameters
.get("repo")
.and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: repo"))?;
let state = parameters
.get("state")
.and_then(|v| v.as_str())
.unwrap_or("open");
let limit = parameters
.get("limit")
.and_then(|v| v.as_u64())
.unwrap_or(30);
let endpoint = format!(
"repos/{}/{}/pulls?state={}&per_page={}",
owner, repo, state, limit
);
GitHubApi::get(&endpoint).await
}
}