303 lines
9.3 KiB
JavaScript
303 lines
9.3 KiB
JavaScript
"use strict";
|
|
/**
|
|
* GitHub API Module
|
|
* Core functions for interacting with GitHub API
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getAuthHeaders = getAuthHeaders;
|
|
exports.getUsername = getUsername;
|
|
exports.listRepos = listRepos;
|
|
exports.getRepo = getRepo;
|
|
exports.checkCIStatus = checkCIStatus;
|
|
exports.getRecentActivity = getRecentActivity;
|
|
exports.createIssue = createIssue;
|
|
exports.createRepo = createRepo;
|
|
exports.searchRepos = searchRepos;
|
|
exports.createPullRequest = createPullRequest;
|
|
const GITHUB_API = 'https://api.github.com';
|
|
// Cached user info
|
|
let cachedUser = null;
|
|
/**
|
|
* Get auth headers for API requests
|
|
*/
|
|
function getAuthHeaders(context) {
|
|
const headers = {
|
|
'Accept': 'application/vnd.github.v3+json',
|
|
'User-Agent': 'OpenClaw-GitHub-Skill'
|
|
};
|
|
// 1. Check environment variable first
|
|
if (process.env.GITHUB_TOKEN) {
|
|
headers['Authorization'] = `token ${process.env.GITHUB_TOKEN}`;
|
|
return headers;
|
|
}
|
|
// 2. Fall back to OpenClaw config
|
|
const config = context.config?.github || {};
|
|
if (config.token) {
|
|
headers['Authorization'] = `token ${config.token}`;
|
|
}
|
|
return headers;
|
|
}
|
|
/**
|
|
* Get GitHub username
|
|
*/
|
|
async function getUsername(context) {
|
|
// 1. Check environment variable first
|
|
if (process.env.GITHUB_USERNAME) {
|
|
return process.env.GITHUB_USERNAME;
|
|
}
|
|
// 2. Check OpenClaw config
|
|
const config = context.config?.github || {};
|
|
if (config.username) {
|
|
return config.username;
|
|
}
|
|
// 3. Fetch from API if not configured
|
|
if (!cachedUser) {
|
|
const response = await fetch(`${GITHUB_API}/user`, {
|
|
headers: getAuthHeaders(context)
|
|
});
|
|
const data = await response.json();
|
|
cachedUser = data.login;
|
|
}
|
|
return cachedUser;
|
|
}
|
|
/**
|
|
* List repositories
|
|
*/
|
|
async function listRepos(args, context) {
|
|
const username = await getUsername(context);
|
|
const { type = 'owner', sort = 'updated', direction = 'desc', limit = 30 } = args;
|
|
const url = `${GITHUB_API}/users/${username}/repos?type=${type}&sort=${sort}&direction=${direction}&per_page=${limit}`;
|
|
const response = await fetch(url, { headers: getAuthHeaders(context) });
|
|
if (!response.ok) {
|
|
throw new Error(`GitHub API error: ${response.status}`);
|
|
}
|
|
const repos = await response.json();
|
|
// Filter by language if specified
|
|
let filtered = repos;
|
|
if (args.language) {
|
|
filtered = repos.filter(r => r.language?.toLowerCase() === args.language.toLowerCase());
|
|
}
|
|
// Limit results
|
|
filtered = filtered.slice(0, limit);
|
|
return {
|
|
total: filtered.length,
|
|
repos: filtered
|
|
};
|
|
}
|
|
/**
|
|
* Get repository details
|
|
*/
|
|
async function getRepo(args, context) {
|
|
const { owner, repo } = args;
|
|
const url = `${GITHUB_API}/repos/${owner}/${repo}`;
|
|
const response = await fetch(url, { headers: getAuthHeaders(context) });
|
|
if (!response.ok) {
|
|
throw new Error(`Repo not found: ${owner}/${repo}`);
|
|
}
|
|
const data = await response.json();
|
|
return {
|
|
name: data.name,
|
|
full_name: data.full_name,
|
|
description: data.description,
|
|
stars: data.stargazers_count,
|
|
forks: data.forks_count,
|
|
watchers: data.watchers_count,
|
|
language: data.language,
|
|
open_issues: data.open_issues_count,
|
|
created: data.created_at,
|
|
updated: data.updated_at,
|
|
pushed: data.pushed_at,
|
|
url: data.html_url,
|
|
default_branch: data.default_branch,
|
|
private: data.private
|
|
};
|
|
}
|
|
/**
|
|
* Check CI/CD status
|
|
*/
|
|
async function checkCIStatus(args, context) {
|
|
const { owner, repo } = args;
|
|
// Get recent workflows/runs
|
|
const runsUrl = `${GITHUB_API}/repos/${owner}/${repo}/actions/runs?per_page=5`;
|
|
const response = await fetch(runsUrl, { headers: getAuthHeaders(context) });
|
|
if (!response.ok) {
|
|
throw new Error(`Failed to get CI status: ${response.status}`);
|
|
}
|
|
const data = await response.json();
|
|
const runs = (data.workflow_runs || []).map((run) => ({
|
|
name: run.name,
|
|
status: run.status,
|
|
conclusion: run.conclusion,
|
|
branch: run.head_branch,
|
|
commit: run.head_sha?.substring(0, 7) || '',
|
|
created: run.created_at,
|
|
url: run.html_url
|
|
}));
|
|
return {
|
|
repo: `${owner}/${repo}`,
|
|
runs
|
|
};
|
|
}
|
|
/**
|
|
* Get recent activity (commits)
|
|
*/
|
|
async function getRecentActivity(args, context) {
|
|
const username = await getUsername(context);
|
|
const { repo, limit = 10 } = args;
|
|
if (!repo) {
|
|
throw new Error('Repository name required');
|
|
}
|
|
// Get recent commits
|
|
const commitsUrl = `${GITHUB_API}/repos/${username}/${repo}/commits?per_page=${limit}`;
|
|
const commitsRes = await fetch(commitsUrl, { headers: getAuthHeaders(context) });
|
|
if (!commitsRes.ok) {
|
|
throw new Error(`Failed to get activity: ${commitsRes.status}`);
|
|
}
|
|
const commits = await commitsRes.json();
|
|
return {
|
|
repo: `${username}/${repo}`,
|
|
commits: commits.map((c) => ({
|
|
sha: c.sha.substring(0, 7),
|
|
message: c.commit.message.split('\n')[0],
|
|
author: c.commit.author.name,
|
|
date: c.commit.author.date,
|
|
url: c.html_url
|
|
}))
|
|
};
|
|
}
|
|
/**
|
|
* Create an issue
|
|
*/
|
|
async function createIssue(args, context) {
|
|
const username = await getUsername(context);
|
|
const { repo, title, body } = args;
|
|
if (!title) {
|
|
throw new Error('Issue title required');
|
|
}
|
|
const url = `${GITHUB_API}/repos/${username}/${repo}/issues`;
|
|
const response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: getAuthHeaders(context),
|
|
body: JSON.stringify({
|
|
title,
|
|
body: body || '',
|
|
...(args.extra || {})
|
|
})
|
|
});
|
|
if (!response.ok) {
|
|
const error = await response.json();
|
|
throw new Error(`Failed to create issue: ${error.message || response.status}`);
|
|
}
|
|
const issue = await response.json();
|
|
return {
|
|
number: issue.number,
|
|
title: issue.title,
|
|
url: issue.html_url,
|
|
state: issue.state
|
|
};
|
|
}
|
|
/**
|
|
* Create a new repository
|
|
*/
|
|
async function createRepo(args, context) {
|
|
const username = await getUsername(context);
|
|
const { name, description, private: isPrivate = false, auto_init = true } = args;
|
|
if (!name) {
|
|
throw new Error('Repository name required');
|
|
}
|
|
const url = `${GITHUB_API}/user/repos`;
|
|
const response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: getAuthHeaders(context),
|
|
body: JSON.stringify({
|
|
name,
|
|
description: description || '',
|
|
private: isPrivate,
|
|
auto_init
|
|
})
|
|
});
|
|
if (!response.ok) {
|
|
const error = await response.json();
|
|
throw new Error(`Failed to create repo: ${error.message || response.status}`);
|
|
}
|
|
const repo = await response.json();
|
|
return {
|
|
name: repo.name,
|
|
full_name: repo.full_name,
|
|
description: repo.description,
|
|
stars: repo.stargazers_count || 0,
|
|
forks: repo.forks_count || 0,
|
|
language: repo.language || null,
|
|
updated: repo.updated_at || '',
|
|
url: repo.html_url,
|
|
private: repo.private
|
|
};
|
|
}
|
|
/**
|
|
* Search repositories
|
|
*/
|
|
async function searchRepos(args, context) {
|
|
const username = await getUsername(context);
|
|
const { query, sort = 'updated', limit = 30 } = args;
|
|
if (!query) {
|
|
throw new Error('Search query required');
|
|
}
|
|
// Search user's repos
|
|
const url = `${GITHUB_API}/search/repositories?q=${encodeURIComponent(query)}+user:${username}&sort=${sort}&per_page=${limit}`;
|
|
const response = await fetch(url, { headers: getAuthHeaders(context) });
|
|
if (!response.ok) {
|
|
throw new Error(`Search failed: ${response.status}`);
|
|
}
|
|
const data = await response.json();
|
|
return {
|
|
total: data.total_count,
|
|
repos: (data.items || []).map((r) => ({
|
|
name: r.name,
|
|
full_name: r.full_name,
|
|
description: r.description,
|
|
stars: r.stargazers_count,
|
|
language: r.language,
|
|
url: r.html_url,
|
|
forks: 0,
|
|
updated: '',
|
|
private: false
|
|
}))
|
|
};
|
|
}
|
|
/**
|
|
* Create a pull request
|
|
*/
|
|
async function createPullRequest(args, context) {
|
|
const username = await getUsername(context);
|
|
const { owner, repo, title, body, head, base = 'main' } = args;
|
|
// Use username if owner not specified
|
|
const prOwner = owner || username;
|
|
if (!prOwner || !repo || !title || !head) {
|
|
throw new Error('owner, repo, title, and head are required');
|
|
}
|
|
const url = `${GITHUB_API}/repos/${prOwner}/${repo}/pulls`;
|
|
const response = await fetch(url, {
|
|
method: 'POST',
|
|
headers: getAuthHeaders(context),
|
|
body: JSON.stringify({
|
|
title,
|
|
body: body || '',
|
|
head,
|
|
base
|
|
})
|
|
});
|
|
if (!response.ok) {
|
|
const error = await response.json();
|
|
throw new Error(`Failed to create PR: ${error.message || response.status}`);
|
|
}
|
|
const pr = await response.json();
|
|
return {
|
|
number: pr.number,
|
|
title: pr.title,
|
|
url: pr.html_url,
|
|
state: pr.state,
|
|
head: pr.head.ref,
|
|
base: pr.base.ref
|
|
};
|
|
}
|
|
//# sourceMappingURL=api.js.map
|