feat: expand MCP tool coverage from 93 to 299 tools
Some checks failed
release-nightly / release-image (push) Failing after 2m17s

Fork the official gitea-mcp and massively extend API coverage:

- Organization: orgs, members, teams, hooks, blocks, activity (34 tools)
- User: profile, followers, keys, emails, repos, blocks (30 tools)
- Repository: collaborators, webhooks, branch/tag protection, deploy keys,
  topics, git refs/trees/notes, commit status, stars/watchers, forks,
  transfers, mirrors, templates (53 tools)
- Issue: reactions, pins, subscriptions, timeline, templates (16 tools)
- Notifications: list, check, read, repo-scoped (7 tools)
- Settings: API, attachment, repo, UI settings (4 tools)
- Packages: list, get, delete, files, latest, link/unlink (7 tools)
- Miscellaneous: server version, gitignore/label/license templates,
  markdown/markup rendering, node info, signing keys (12 tools)
- Admin: user/org/repo CRUD, system webhooks, cron tasks, unadopted
  repos, emails, badges (23 tools)

Module path updated to git.lethalbits.com/lethalbits/gitea-mcp.
This commit is contained in:
Andrew Miller
2026-03-05 11:03:20 -05:00
parent 9ce5604e4c
commit df25d328d1
66 changed files with 6976 additions and 122 deletions

View File

@@ -0,0 +1,325 @@
package miscellaneous
import (
"context"
"errors"
"fmt"
"git.lethalbits.com/lethalbits/gitea-mcp/pkg/gitea"
"git.lethalbits.com/lethalbits/gitea-mcp/pkg/log"
"git.lethalbits.com/lethalbits/gitea-mcp/pkg/to"
"git.lethalbits.com/lethalbits/gitea-mcp/pkg/tool"
gitea_sdk "code.gitea.io/sdk/gitea"
"github.com/mark3labs/mcp-go/mcp"
"github.com/mark3labs/mcp-go/server"
)
var Tool = tool.New()
const (
GetServerVersionToolName = "get_server_version"
ListGitignoreTemplatesToolName = "list_gitignore_templates"
GetGitignoreTemplateToolName = "get_gitignore_template"
ListLabelTemplatesToolName = "list_label_templates"
GetLabelTemplateToolName = "get_label_template"
ListLicenseTemplatesToolName = "list_license_templates"
GetLicenseTemplateToolName = "get_license_template"
RenderMarkdownToolName = "render_markdown"
RenderMarkupToolName = "render_markup"
GetNodeInfoToolName = "get_node_info"
GetSigningKeyGPGToolName = "get_signing_key_gpg"
GetSigningKeySSHToolName = "get_signing_key_ssh"
)
var (
GetServerVersionTool = mcp.NewTool(
GetServerVersionToolName,
mcp.WithDescription("Get the Gitea server version"),
)
ListGitignoreTemplatesTool = mcp.NewTool(
ListGitignoreTemplatesToolName,
mcp.WithDescription("List available .gitignore templates"),
)
GetGitignoreTemplateTool = mcp.NewTool(
GetGitignoreTemplateToolName,
mcp.WithDescription("Get the content of a .gitignore template by name"),
mcp.WithString("name", mcp.Required(), mcp.Description("template name (e.g., Go, Python, Node)")),
)
ListLabelTemplatesTool = mcp.NewTool(
ListLabelTemplatesToolName,
mcp.WithDescription("List available label templates"),
)
GetLabelTemplateTool = mcp.NewTool(
GetLabelTemplateToolName,
mcp.WithDescription("Get the labels from a label template"),
mcp.WithString("name", mcp.Required(), mcp.Description("template name")),
)
ListLicenseTemplatesTool = mcp.NewTool(
ListLicenseTemplatesToolName,
mcp.WithDescription("List available license templates"),
)
GetLicenseTemplateTool = mcp.NewTool(
GetLicenseTemplateToolName,
mcp.WithDescription("Get the content of a license template"),
mcp.WithString("name", mcp.Required(), mcp.Description("license name (e.g., MIT, GPL-3.0, Apache-2.0)")),
)
RenderMarkdownTool = mcp.NewTool(
RenderMarkdownToolName,
mcp.WithDescription("Render markdown text to HTML"),
mcp.WithString("text", mcp.Required(), mcp.Description("markdown text to render")),
mcp.WithString("mode", mcp.Description("render mode: markdown, gfm, comment (default: markdown)")),
mcp.WithString("context", mcp.Description("context for relative links (owner/repo format)")),
mcp.WithBoolean("wiki", mcp.Description("treat text as wiki content")),
)
RenderMarkupTool = mcp.NewTool(
RenderMarkupToolName,
mcp.WithDescription("Render markup content to HTML (supports multiple markup languages)"),
mcp.WithString("text", mcp.Required(), mcp.Description("markup text to render")),
mcp.WithString("mode", mcp.Description("render mode")),
mcp.WithString("context", mcp.Description("context for relative links (owner/repo format)")),
mcp.WithString("filepath", mcp.Description("file path to determine markup language")),
mcp.WithBoolean("wiki", mcp.Description("treat text as wiki content")),
)
GetNodeInfoTool = mcp.NewTool(
GetNodeInfoToolName,
mcp.WithDescription("Get the NodeInfo of the Gitea instance (federation metadata)"),
)
GetSigningKeyGPGTool = mcp.NewTool(
GetSigningKeyGPGToolName,
mcp.WithDescription("Get the GPG signing key of the Gitea instance"),
)
GetSigningKeySSHTool = mcp.NewTool(
GetSigningKeySSHToolName,
mcp.WithDescription("Get the SSH signing key of the Gitea instance"),
)
)
func init() {
Tool.RegisterRead(server.ServerTool{Tool: GetServerVersionTool, Handler: GetServerVersionFn})
Tool.RegisterRead(server.ServerTool{Tool: ListGitignoreTemplatesTool, Handler: ListGitignoreTemplatesFn})
Tool.RegisterRead(server.ServerTool{Tool: GetGitignoreTemplateTool, Handler: GetGitignoreTemplateFn})
Tool.RegisterRead(server.ServerTool{Tool: ListLabelTemplatesTool, Handler: ListLabelTemplatesFn})
Tool.RegisterRead(server.ServerTool{Tool: GetLabelTemplateTool, Handler: GetLabelTemplateFn})
Tool.RegisterRead(server.ServerTool{Tool: ListLicenseTemplatesTool, Handler: ListLicenseTemplatesFn})
Tool.RegisterRead(server.ServerTool{Tool: GetLicenseTemplateTool, Handler: GetLicenseTemplateFn})
Tool.RegisterRead(server.ServerTool{Tool: GetNodeInfoTool, Handler: GetNodeInfoFn})
Tool.RegisterRead(server.ServerTool{Tool: GetSigningKeyGPGTool, Handler: GetSigningKeyGPGFn})
Tool.RegisterRead(server.ServerTool{Tool: GetSigningKeySSHTool, Handler: GetSigningKeySSHFn})
Tool.RegisterWrite(server.ServerTool{Tool: RenderMarkdownTool, Handler: RenderMarkdownFn})
Tool.RegisterWrite(server.ServerTool{Tool: RenderMarkupTool, Handler: RenderMarkupFn})
}
func GetServerVersionFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetServerVersionFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
version, _, err := client.ServerVersion()
if err != nil {
return to.ErrorResult(fmt.Errorf("get server version err: %v", err))
}
return to.TextResult(map[string]string{"version": version})
}
func ListGitignoreTemplatesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called ListGitignoreTemplatesFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
templates, _, err := client.ListGitignoresTemplates()
if err != nil {
return to.ErrorResult(fmt.Errorf("list gitignore templates err: %v", err))
}
return to.TextResult(templates)
}
func GetGitignoreTemplateFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetGitignoreTemplateFn")
name, _ := req.GetArguments()["name"].(string)
if name == "" {
return to.ErrorResult(errors.New("name is required"))
}
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
info, _, err := client.GetGitignoreTemplateInfo(name)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitignore template err: %v", err))
}
return to.TextResult(info)
}
func ListLabelTemplatesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called ListLabelTemplatesFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
templates, _, err := client.ListLabelTemplates()
if err != nil {
return to.ErrorResult(fmt.Errorf("list label templates err: %v", err))
}
return to.TextResult(templates)
}
func GetLabelTemplateFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetLabelTemplateFn")
name, _ := req.GetArguments()["name"].(string)
if name == "" {
return to.ErrorResult(errors.New("name is required"))
}
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
labels, _, err := client.GetLabelTemplate(name)
if err != nil {
return to.ErrorResult(fmt.Errorf("get label template err: %v", err))
}
return to.TextResult(labels)
}
func ListLicenseTemplatesFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called ListLicenseTemplatesFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
templates, _, err := client.ListLicenseTemplates()
if err != nil {
return to.ErrorResult(fmt.Errorf("list license templates err: %v", err))
}
return to.TextResult(templates)
}
func GetLicenseTemplateFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetLicenseTemplateFn")
name, _ := req.GetArguments()["name"].(string)
if name == "" {
return to.ErrorResult(errors.New("name is required"))
}
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
info, _, err := client.GetLicenseTemplateInfo(name)
if err != nil {
return to.ErrorResult(fmt.Errorf("get license template err: %v", err))
}
return to.TextResult(info)
}
func RenderMarkdownFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called RenderMarkdownFn")
text, _ := req.GetArguments()["text"].(string)
if text == "" {
return to.ErrorResult(errors.New("text is required"))
}
opt := gitea_sdk.MarkdownOption{
Text: text,
}
if v, ok := req.GetArguments()["mode"].(string); ok {
opt.Mode = v
}
if v, ok := req.GetArguments()["context"].(string); ok {
opt.Context = v
}
if v, ok := req.GetArguments()["wiki"].(bool); ok {
opt.Wiki = v
}
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
html, _, err := client.RenderMarkdown(opt)
if err != nil {
return to.ErrorResult(fmt.Errorf("render markdown err: %v", err))
}
return to.TextResult(map[string]string{"html": html})
}
func RenderMarkupFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called RenderMarkupFn")
text, _ := req.GetArguments()["text"].(string)
if text == "" {
return to.ErrorResult(errors.New("text is required"))
}
opt := gitea_sdk.MarkupOption{
Text: text,
}
if v, ok := req.GetArguments()["mode"].(string); ok {
opt.Mode = v
}
if v, ok := req.GetArguments()["context"].(string); ok {
opt.Context = v
}
if v, ok := req.GetArguments()["filepath"].(string); ok {
opt.FilePath = v
}
if v, ok := req.GetArguments()["wiki"].(bool); ok {
opt.Wiki = v
}
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
html, _, err := client.RenderMarkup(opt)
if err != nil {
return to.ErrorResult(fmt.Errorf("render markup err: %v", err))
}
return to.TextResult(map[string]string{"html": html})
}
func GetNodeInfoFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetNodeInfoFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
info, _, err := client.GetNodeInfo()
if err != nil {
return to.ErrorResult(fmt.Errorf("get node info err: %v", err))
}
return to.TextResult(info)
}
func GetSigningKeyGPGFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetSigningKeyGPGFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
key, _, err := client.GetSigningKeyGPG()
if err != nil {
return to.ErrorResult(fmt.Errorf("get signing key GPG err: %v", err))
}
return to.TextResult(map[string]string{"gpg_key": key})
}
func GetSigningKeySSHFn(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
log.Debugf("Called GetSigningKeySSHFn")
client, err := gitea.ClientFromContext(ctx)
if err != nil {
return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
}
key, _, err := client.GetSigningKeySSH()
if err != nil {
return to.ErrorResult(fmt.Errorf("get signing key SSH err: %v", err))
}
return to.TextResult(map[string]string{"ssh_key": key})
}