feat(connector): add search and fetch tools for ChatGPT connectors

Add a new "connector" domain exposing exactly-named "search" and "fetch"
MCP tools for ChatGPT-style connector compatibility (gitea#84). search
looks up repositories via the existing SearchRepos SDK call, optionally
resolving an owner/org name to an owner ID, and returns concise entries
(id, name, url, html_url). fetch reuses GetContents to read a file and
decodes its base64 content, returning path, sha, size, encoding and the
decoded content. Registers connector.Tool in operation.go and documents
the two tools in all three README tables.

Co-Authored-By: Codet <codet@commitgo.dev> (GPT-5-Codex)

README.md

@@ -191,6 +191,8 @@ Once configured, try `list all my repositories` in the chat box.
 | get_release                  | release      | Read   | Get a release by ID |
 | get_latest_release           | release      | Read   | Get the latest release |
 | list_releases                | release      | Read   | List repository releases |
+| search                       | connector    | Read   | Search Gitea repositories by keyword for ChatGPT-style connectors |
+| fetch                        | connector    | Read   | Fetch a file's decoded content and metadata for ChatGPT-style connectors |
 
 > **Note:** Several tools are consolidated, action-based tools, a single tool exposes multiple operations through a `method` parameter. Tools with `Write` access are hidden when the server runs in read-only mode (`-r` / `GITEA_READONLY`), and the exposed tool set can be filtered by scope with `-S` / `--scope` (`GITEA_SCOPES`) and/or by individual tool name with `-O` / `--tools` (`GITEA_TOOLS`).
 

README.zh-cn.md

@@ -191,6 +191,8 @@ Cursor 等客户端可使用 stdio 命令：
 | get_release                  | release      | 读取 | 按 ID 获取版本发布 |
 | get_latest_release           | release      | 读取 | 获取最新版本发布 |
 | list_releases                | release      | 读取 | 列出仓库版本发布 |
+| search                       | connector    | 读取 | 为 ChatGPT 风格的连接器按关键字搜索 Gitea 仓库 |
+| fetch                        | connector    | 读取 | 为 ChatGPT 风格的连接器获取文件的解码内容与元数据 |
 
 > **说明：** 部分工具是聚合的、基于操作的工具，单个工具通过 `method` 参数暴露多个操作。当服务器以只读模式运行时（`-r` / `GITEA_READONLY`），访问为「写入」的工具会被隐藏；可通过 `-S` / `--scope`（`GITEA_SCOPES`）按范围过滤，或通过 `-O` / `--tools`（`GITEA_TOOLS`）按工具名称过滤对外暴露的工具集合。
 

README.zh-tw.md

@@ -191,6 +191,8 @@ Cursor 等客戶端可使用 stdio 命令：
 | get_release                  | release      | 讀取 | 依 ID 取得版本發布 |
 | get_latest_release           | release      | 讀取 | 取得最新版本發布 |
 | list_releases                | release      | 讀取 | 列出倉庫版本發布 |
+| search                       | connector    | 讀取 | 為 ChatGPT 風格的連接器依關鍵字搜尋 Gitea 倉庫 |
+| fetch                        | connector    | 讀取 | 為 ChatGPT 風格的連接器取得檔案的解碼內容與中繼資料 |
 
 > **說明：** 部分工具是聚合的、基於操作的工具，單個工具透過 `method` 參數暴露多個操作。當伺服器以唯讀模式執行時（`-r` / `GITEA_READONLY`），存取為「寫入」的工具會被隱藏；可透過 `-S` / `--scope`（`GITEA_SCOPES`）依範圍過濾，或透過 `-O` / `--tools`（`GITEA_TOOLS`）依工具名稱過濾對外暴露的工具集合。
 

operation/connector/connector.go

@@ -0,0 +1,159 @@
+// Package connector provides the "search" and "fetch" tools expected by
+// ChatGPT-style MCP connectors (https://platform.openai.com/docs/mcp), on
+// top of the same Gitea SDK calls the search and file domains already use.
+package connector
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+
+	"gitea.com/gitea/gitea-mcp/pkg/annotation"
+	"gitea.com/gitea/gitea-mcp/pkg/gitea"
+	"gitea.com/gitea/gitea-mcp/pkg/params"
+	"gitea.com/gitea/gitea-mcp/pkg/to"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	gitea_sdk "gitea.dev/sdk"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+// Tool holds the connector tools (scope "connector"): search and fetch.
+var Tool = tool.New("connector")
+
+const (
+	SearchToolName = "search"
+	FetchToolName  = "fetch"
+)
+
+var (
+	SearchTool = tool.NewDefinition(
+		SearchToolName,
+		"Search Gitea repositories by keyword. Returns concise entries suitable for ChatGPT-style connectors.",
+		annotation.ReadOnly("Search"),
+		tool.String("query", tool.Required(), tool.Description("search keyword")),
+		tool.String("owner", tool.Description("filter results to repositories owned by this user")),
+		tool.String("org", tool.Description("filter results to repositories owned by this organization")),
+		tool.Number("page", tool.Description(params.PageDesc), tool.Default(1)),
+		tool.Number("per_page", tool.Description(params.PaginationDesc), tool.Default(30)),
+	)
+
+	FetchTool = tool.NewDefinition(
+		FetchToolName,
+		"Fetch a file's decoded content and metadata from a Gitea repository. Suitable for ChatGPT-style connectors.",
+		annotation.ReadOnly("Fetch"),
+		tool.String("owner", tool.Required(), tool.Description(params.OwnerDesc)),
+		tool.String("repo", tool.Required(), tool.Description(params.RepoDesc)),
+		tool.String("path", tool.Required()),
+		tool.String("ref", tool.Description("branch, tag, or commit SHA")),
+	)
+)
+
+func init() {
+	Tool.RegisterRead(tool.ServerTool{
+		Tool:    SearchTool,
+		Handler: SearchFn,
+	})
+	Tool.RegisterRead(tool.ServerTool{
+		Tool:    FetchTool,
+		Handler: FetchFn,
+	})
+}
+
+// SearchFn searches Gitea repositories by keyword, optionally scoped to an
+// owner or organization, and returns concise entries.
+func SearchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	query, err := params.GetString(args, "query")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+
+	ownerName := params.GetOptionalString(args, "owner", "")
+	if ownerName == "" {
+		ownerName = params.GetOptionalString(args, "org", "")
+	}
+	var ownerID int64
+	if ownerName != "" {
+		owner, _, err := client.Users.GetUserInfo(ctx, ownerName)
+		if err != nil {
+			return to.ErrorResult(fmt.Errorf("resolve owner %q err: %v", ownerName, err))
+		}
+		ownerID = owner.ID
+	}
+
+	page, pageSize := params.GetPagination(args, 30)
+	opt := gitea_sdk.SearchRepoOptions{
+		Keyword: query,
+		OwnerID: ownerID,
+		ListOptions: gitea_sdk.ListOptions{
+			Page:     page,
+			PageSize: pageSize,
+		},
+	}
+	repos, _, err := client.Repositories.SearchRepos(ctx, opt)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("search repos err: %v", err))
+	}
+	return to.TextResult(slimSearchResults(repos))
+}
+
+// FetchFn fetches a file's content and decodes it, returning the decoded
+// content alongside path, sha, size, and encoding metadata.
+func FetchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	filePath, err := params.GetString(args, "path")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	ref := params.GetOptionalString(args, "ref", "")
+
+	client, err := gitea.ClientFromContext(ctx)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
+	}
+	content, _, err := client.Repositories.GetContents(ctx, owner, repo, ref, filePath)
+	if err != nil {
+		return to.ErrorResult(fmt.Errorf("get file err: %v", err))
+	}
+
+	decoded, err := decodeContent(content)
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	return to.TextResult(map[string]any{
+		"path":     content.Path,
+		"sha":      content.SHA,
+		"size":     content.Size,
+		"encoding": stringOrEmpty(content.Encoding),
+		"content":  decoded,
+	})
+}
+
+func decodeContent(c *gitea_sdk.ContentsResponse) (string, error) {
+	if c.Content == nil {
+		return "", nil
+	}
+	raw, err := base64.StdEncoding.DecodeString(*c.Content)
+	if err != nil {
+		return "", fmt.Errorf("decode base64 content err: %v", err)
+	}
+	return string(raw), nil
+}
+
+func stringOrEmpty(s *string) string {
+	if s == nil {
+		return ""
+	}
+	return *s
+}

operation/connector/connector_test.go

@@ -0,0 +1,155 @@
+package connector
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+func withTestServer(t *testing.T, handler http.HandlerFunc) {
+	t.Helper()
+	server := httptest.NewServer(handler)
+	t.Cleanup(server.Close)
+
+	origHost, origToken := flag.Host, flag.Token
+	flag.Host, flag.Token = server.URL, ""
+	t.Cleanup(func() { flag.Host, flag.Token = origHost, origToken })
+}
+
+func resultText(t *testing.T, result *mcp.CallToolResult) string {
+	t.Helper()
+	text, ok := result.Content[0].(*mcp.TextContent)
+	if !ok {
+		t.Fatalf("result content = %T, want *mcp.TextContent", result.Content[0])
+	}
+	return text.Text
+}
+
+func TestSearchFnReturnsConciseRepoEntries(t *testing.T) {
+	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		if strings.HasSuffix(r.URL.Path, "/version") {
+			_, _ = w.Write([]byte(`{"version":"1.26.0"}`))
+			return
+		}
+		if !strings.HasSuffix(r.URL.Path, "/repos/search") {
+			t.Fatalf("unexpected request path %q", r.URL.Path)
+		}
+		if q := r.URL.Query().Get("q"); q != "gitea-mcp" {
+			t.Fatalf("query q = %q, want gitea-mcp", q)
+		}
+		_, _ = w.Write([]byte(`{"data":[{"id":42,"name":"gitea-mcp","full_name":"gitea/gitea-mcp","html_url":"https://gitea.com/gitea/gitea-mcp","description":"MCP server"}]}`))
+	})
+
+	result, err := SearchFn(context.Background(), map[string]any{"query": "gitea-mcp"})
+	if err != nil {
+		t.Fatalf("SearchFn() error = %v", err)
+	}
+
+	var entries []map[string]any
+	if err := json.Unmarshal([]byte(resultText(t, result)), &entries); err != nil {
+		t.Fatalf("unmarshal result: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("len(entries) = %d, want 1", len(entries))
+	}
+	entry := entries[0]
+	if entry["id"] != float64(42) {
+		t.Errorf("id = %v, want 42", entry["id"])
+	}
+	if entry["name"] != "gitea-mcp" {
+		t.Errorf("name = %v, want gitea-mcp", entry["name"])
+	}
+	if entry["url"] != "https://gitea.com/gitea/gitea-mcp" {
+		t.Errorf("url = %v, want the repo html_url", entry["url"])
+	}
+	if entry["html_url"] != "https://gitea.com/gitea/gitea-mcp" {
+		t.Errorf("html_url = %v, want the repo html_url", entry["html_url"])
+	}
+}
+
+func TestSearchFnRequiresQuery(t *testing.T) {
+	result, err := SearchFn(context.Background(), map[string]any{})
+	if err != nil {
+		t.Fatalf("SearchFn() error = %v", err)
+	}
+	if !result.IsError {
+		t.Fatal("SearchFn() result.IsError = false, want true for a missing query")
+	}
+}
+
+func TestSearchFnResolvesOwnerFilterToOwnerID(t *testing.T) {
+	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/version"):
+			_, _ = w.Write([]byte(`{"version":"1.26.0"}`))
+		case strings.HasSuffix(r.URL.Path, "/users/octo"):
+			_, _ = w.Write([]byte(`{"id":7,"login":"octo"}`))
+		case strings.HasSuffix(r.URL.Path, "/repos/search"):
+			if uid := r.URL.Query().Get("uid"); uid != "7" {
+				t.Fatalf("uid = %q, want 7", uid)
+			}
+			_, _ = w.Write([]byte(`{"data":[]}`))
+		default:
+			t.Fatalf("unexpected request path %q", r.URL.Path)
+		}
+	})
+
+	if _, err := SearchFn(context.Background(), map[string]any{"query": "demo", "owner": "octo"}); err != nil {
+		t.Fatalf("SearchFn() error = %v", err)
+	}
+}
+
+func TestFetchFnReturnsDecodedContentAndMetadata(t *testing.T) {
+	withTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		if !strings.Contains(r.URL.Path, "/contents/") {
+			t.Fatalf("unexpected request path %q", r.URL.Path)
+		}
+		_, _ = w.Write([]byte(`{"name":"README.md","path":"README.md","sha":"abc123","type":"file","size":11,"encoding":"base64","content":"aGVsbG8gd29ybGQ="}`))
+	})
+
+	result, err := FetchFn(context.Background(), map[string]any{
+		"owner": "octo",
+		"repo":  "demo",
+		"path":  "README.md",
+	})
+	if err != nil {
+		t.Fatalf("FetchFn() error = %v", err)
+	}
+
+	var got map[string]any
+	if err := json.Unmarshal([]byte(resultText(t, result)), &got); err != nil {
+		t.Fatalf("unmarshal result: %v", err)
+	}
+	if got["content"] != "hello world" {
+		t.Errorf("content = %v, want decoded %q", got["content"], "hello world")
+	}
+	if got["path"] != "README.md" {
+		t.Errorf("path = %v, want README.md", got["path"])
+	}
+	if got["sha"] != "abc123" {
+		t.Errorf("sha = %v, want abc123", got["sha"])
+	}
+	if got["size"] != float64(11) {
+		t.Errorf("size = %v, want 11", got["size"])
+	}
+	if got["encoding"] != "base64" {
+		t.Errorf("encoding = %v, want base64", got["encoding"])
+	}
+}
+
+func TestFetchFnRequiresPath(t *testing.T) {
+	result, err := FetchFn(context.Background(), map[string]any{"owner": "octo", "repo": "demo"})
+	if err != nil {
+		t.Fatalf("FetchFn() error = %v", err)
+	}
+	if !result.IsError {
+		t.Fatal("FetchFn() result.IsError = false, want true for a missing path")
+	}
+}

operation/connector/slim.go

@@ -0,0 +1,29 @@
+package connector
+
+import (
+	gitea_sdk "gitea.dev/sdk"
+)
+
+// slimSearchResult is the concise entry shape ChatGPT-style connectors
+// expect from search: an id, a title, and a url to fetch it by.
+func slimSearchResult(r *gitea_sdk.Repository) map[string]any {
+	if r == nil {
+		return nil
+	}
+	return map[string]any{
+		"id":          r.ID,
+		"name":        r.Name,
+		"full_name":   r.FullName,
+		"description": r.Description,
+		"url":         r.HTMLURL,
+		"html_url":    r.HTMLURL,
+	}
+}
+
+func slimSearchResults(repos []*gitea_sdk.Repository) []map[string]any {
+	out := make([]map[string]any, 0, len(repos))
+	for _, r := range repos {
+		out = append(out, slimSearchResult(r))
+	}
+	return out
+}

operation/operation.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"gitea.com/gitea/gitea-mcp/operation/actions"
+	"gitea.com/gitea/gitea-mcp/operation/connector"
 	"gitea.com/gitea/gitea-mcp/operation/issue"
 	"gitea.com/gitea/gitea-mcp/operation/label"
 	"gitea.com/gitea/gitea-mcp/operation/milestone"
@@ -47,7 +48,7 @@ var (
 	domainTools = []*tool.Tool{
 		user.Tool, actions.Tool, repo.Tool, notification.Tool, issue.Tool,
 		label.Tool, milestone.Tool, packages.Tool, pull.Tool, search.Tool,
-		version.Tool, wiki.Tool, timetracking.Tool,
+		version.Tool, wiki.Tool, timetracking.Tool, connector.Tool,
 		repo.FileTool, repo.BranchTool, repo.TagTool, repo.CommitTool, repo.ReleaseTool,
 	}
 )

operation/repo/branch.go

@@ -69,26 +69,28 @@ func init() {
 	})
 }
 
-type createBranchArgs struct {
-	Owner     string `json:"owner" required:"true"`
-	Repo      string `json:"repo" required:"true"`
-	Branch    string `json:"branch" required:"true"`
-	OldBranch string `json:"old_branch"`
-}
-
 func CreateBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in createBranchArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	branch, err := params.GetString(args, "branch")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	oldBranch, _ := args["old_branch"].(string)
 
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, _, err = client.Repositories.CreateBranch(ctx, in.Owner, in.Repo, gitea_sdk.CreateBranchOption{
-		BranchName:    in.Branch,
-		OldBranchName: in.OldBranch,
+	_, _, err = client.Repositories.CreateBranch(ctx, owner, repo, gitea_sdk.CreateBranchOption{
+		BranchName:    branch,
+		OldBranchName: oldBranch,
 	})
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create branch error: %v", err))
@@ -97,22 +99,24 @@ func CreateBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	return to.TextResult("Branch Created")
 }
 
-type deleteBranchArgs struct {
-	Owner  string `json:"owner" required:"true"`
-	Repo   string `json:"repo" required:"true"`
-	Branch string `json:"branch" required:"true"`
-}
-
 func DeleteBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in deleteBranchArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	branch, err := params.GetString(args, "branch")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, _, err = client.Repositories.DeleteRepoBranch(ctx, in.Owner, in.Repo, in.Branch)
+	_, _, err = client.Repositories.DeleteRepoBranch(ctx, owner, repo, branch)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete branch error: %v", err))
 	}
@@ -120,14 +124,13 @@ func DeleteBranchFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	return to.TextResult("Branch Deleted")
 }
 
-type listBranchesArgs struct {
-	Owner string `json:"owner" required:"true"`
-	Repo  string `json:"repo" required:"true"`
-}
-
 func ListBranchesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in listBranchesArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
 	page, pageSize := params.GetPagination(args, 30)
@@ -141,7 +144,7 @@ func ListBranchesFn(ctx context.Context, args map[string]any) (*mcp.CallToolResu
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	branches, _, err := client.Repositories.ListRepoBranches(ctx, in.Owner, in.Repo, opt)
+	branches, _, err := client.Repositories.ListRepoBranches(ctx, owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("list branches error: %v", err))
 	}

operation/repo/file.go

@@ -102,28 +102,30 @@ type ContentLine struct {
 	Content    string `json:"content"`
 }
 
-type getFileContentArgs struct {
-	Owner     string `json:"owner" required:"true"`
-	Repo      string `json:"repo" required:"true"`
-	Ref       string `json:"ref"`
-	Path      string `json:"path" required:"true"`
-	WithLines bool   `json:"withLines"`
-}
-
 func GetFileContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in getFileContentArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	ref, _ := args["ref"].(string)
+	filePath, err := params.GetString(args, "path")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	content, _, err := client.Repositories.GetContents(ctx, in.Owner, in.Repo, in.Ref, in.Path)
+	content, _, err := client.Repositories.GetContents(ctx, owner, repo, ref, filePath)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get file err: %v", err))
 	}
-	if in.WithLines {
+	withLines, _ := args["withLines"].(bool)
+	if withLines {
 		rawContent, err := base64.StdEncoding.DecodeString(*content.Content)
 		if err != nil {
 			return to.ErrorResult(fmt.Errorf("decode base64 content err: %v", err))
@@ -162,45 +164,49 @@ func GetFileContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolRe
 	return to.TextResult(slimContents(content))
 }
 
-type getDirContentArgs struct {
-	Owner string `json:"owner" required:"true"`
-	Repo  string `json:"repo" required:"true"`
-	Ref   string `json:"ref"`
-	Path  string `json:"path" required:"true"`
-}
-
 func GetDirContentFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in getDirContentArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	ref, _ := args["ref"].(string)
+	filePath, err := params.GetString(args, "path")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	content, _, err := client.Repositories.ListContents(ctx, in.Owner, in.Repo, in.Ref, in.Path)
+	content, _, err := client.Repositories.ListContents(ctx, owner, repo, ref, filePath)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get dir content err: %v", err))
 	}
 	return to.TextResult(slimDirEntries(content))
 }
 
-type createOrUpdateFileArgs struct {
-	Owner         string `json:"owner" required:"true"`
-	Repo          string `json:"repo" required:"true"`
-	Path          string `json:"path" required:"true"`
-	Content       string `json:"content"`
-	Message       string `json:"message"`
-	BranchName    string `json:"branch_name"`
-	NewBranchName string `json:"new_branch_name"`
-	SHA           string `json:"sha"`
-}
-
 func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in createOrUpdateFileArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	filePath, err := params.GetString(args, "path")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	content, _ := args["content"].(string)
+	message, _ := args["message"].(string)
+	branchName, _ := args["branch_name"].(string)
+	newBranchName, _ := args["new_branch_name"].(string)
+	sha, _ := args["sha"].(string)
 
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
@@ -208,20 +214,20 @@ func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallTo
 	}
 
 	fileOpt := gitea_sdk.FileOptions{
-		Message:       in.Message,
-		BranchName:    in.BranchName,
-		NewBranchName: in.NewBranchName,
+		Message:       message,
+		BranchName:    branchName,
+		NewBranchName: newBranchName,
 	}
-	targetBranch := cmp.Or(in.NewBranchName, in.BranchName)
+	targetBranch := cmp.Or(newBranchName, branchName)
 
-	if in.SHA != "" {
+	if sha != "" {
 		// Update existing file
 		opt := gitea_sdk.UpdateFileOptions{
-			SHA:         in.SHA,
-			Content:     base64.StdEncoding.EncodeToString([]byte(in.Content)),
+			SHA:         sha,
+			Content:     base64.StdEncoding.EncodeToString([]byte(content)),
 			FileOptions: fileOpt,
 		}
-		_, _, err = client.Repositories.UpdateFile(ctx, in.Owner, in.Repo, in.Path, opt)
+		_, _, err = client.Repositories.UpdateFile(ctx, owner, repo, filePath, opt)
 		if err != nil {
 			return to.ErrorResult(fmt.Errorf("update file err: %v", err))
 		}
@@ -230,42 +236,47 @@ func CreateOrUpdateFileFn(ctx context.Context, args map[string]any) (*mcp.CallTo
 
 	// Create new file
 	opt := gitea_sdk.CreateFileOptions{
-		Content:     base64.StdEncoding.EncodeToString([]byte(in.Content)),
+		Content:     base64.StdEncoding.EncodeToString([]byte(content)),
 		FileOptions: fileOpt,
 	}
-	_, _, err = client.Repositories.CreateFile(ctx, in.Owner, in.Repo, in.Path, opt)
+	_, _, err = client.Repositories.CreateFile(ctx, owner, repo, filePath, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("create file err: %v", err))
 	}
 	return to.TextResult("Create file success on branch " + targetBranch)
 }
 
-type deleteFileArgs struct {
-	Owner      string `json:"owner" required:"true"`
-	Repo       string `json:"repo" required:"true"`
-	Path       string `json:"path" required:"true"`
-	Message    string `json:"message"`
-	BranchName string `json:"branch_name"`
-	SHA        string `json:"sha" required:"true"`
-}
-
 func DeleteFileFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in deleteFileArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	filePath, err := params.GetString(args, "path")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	message, _ := args["message"].(string)
+	branchName, _ := args["branch_name"].(string)
+	sha, err := params.GetString(args, "sha")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
 	opt := gitea_sdk.DeleteFileOptions{
 		FileOptions: gitea_sdk.FileOptions{
-			Message:    in.Message,
-			BranchName: in.BranchName,
+			Message:    message,
+			BranchName: branchName,
 		},
-		SHA: in.SHA,
+		SHA: sha,
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	_, err = client.Repositories.DeleteFile(ctx, in.Owner, in.Repo, in.Path, opt)
+	_, err = client.Repositories.DeleteFile(ctx, owner, repo, filePath, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("delete file err: %v", err))
 	}

operation/repo/tree.go

@@ -37,18 +37,20 @@ func init() {
 	})
 }
 
-type getRepoTreeArgs struct {
-	Owner     string `json:"owner" required:"true"`
-	Repo      string `json:"repo" required:"true"`
-	TreeSHA   string `json:"tree_sha" required:"true"`
-	Recursive bool   `json:"recursive"`
-}
-
 func GetRepoTreeFn(ctx context.Context, args map[string]any) (*mcp.CallToolResult, error) {
-	var in getRepoTreeArgs
-	if err := params.Bind(args, &in); err != nil {
+	owner, err := params.GetString(args, "owner")
+	if err != nil {
 		return to.ErrorResult(err)
 	}
+	repo, err := params.GetString(args, "repo")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	treeSHA, err := params.GetString(args, "tree_sha")
+	if err != nil {
+		return to.ErrorResult(err)
+	}
+	recursive, _ := args["recursive"].(bool)
 	page, pageSize := params.GetPagination(args, 30)
 
 	opt := gitea_sdk.ListTreeOptions{
@@ -56,14 +58,14 @@ func GetRepoTreeFn(ctx context.Context, args map[string]any) (*mcp.CallToolResul
 			Page:     page,
 			PageSize: pageSize,
 		},
-		Ref:       in.TreeSHA,
-		Recursive: in.Recursive,
+		Ref:       treeSHA,
+		Recursive: recursive,
 	}
 	client, err := gitea.ClientFromContext(ctx)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get gitea client err: %v", err))
 	}
-	tree, _, err := client.Git.GetTrees(ctx, in.Owner, in.Repo, opt)
+	tree, _, err := client.Git.GetTrees(ctx, owner, repo, opt)
 	if err != nil {
 		return to.ErrorResult(fmt.Errorf("get repository tree err: %v", err))
 	}

pkg/params/bind.go

@@ -1,55 +0,0 @@
-package params
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-// Bind decodes args into out, a pointer to a struct, replacing the repeated
-// args["x"].(string)/!ok extraction pattern. It round-trips args through JSON
-// so JSON numbers land in the correct Go numeric field types.
-//
-// Struct fields tagged `required:"true"` must be present in args; a missing
-// key, or an empty string value for a string field, returns an error naming
-// the field's json tag.
-func Bind(args map[string]any, out any) error {
-	v := reflect.ValueOf(out)
-	if v.Kind() != reflect.Pointer || v.Elem().Kind() != reflect.Struct {
-		return fmt.Errorf("params.Bind: out must be a pointer to a struct, got %T", out)
-	}
-
-	if err := checkRequiredFields(args, v.Elem().Type()); err != nil {
-		return err
-	}
-
-	data, err := json.Marshal(args)
-	if err != nil {
-		return fmt.Errorf("params.Bind: marshal args: %w", err)
-	}
-	if err := json.Unmarshal(data, out); err != nil {
-		return fmt.Errorf("params.Bind: %w", err)
-	}
-	return nil
-}
-
-func checkRequiredFields(args map[string]any, t reflect.Type) error {
-	for field := range t.Fields() {
-		if field.Tag.Get("required") != "true" {
-			continue
-		}
-		name, _, _ := strings.Cut(field.Tag.Get("json"), ",")
-		if name == "" || name == "-" {
-			continue
-		}
-		val, ok := args[name]
-		if !ok {
-			return fmt.Errorf("%s is required", name)
-		}
-		if s, isString := val.(string); isString && s == "" {
-			return fmt.Errorf("%s is required", name)
-		}
-	}
-	return nil
-}

pkg/params/bind_test.go

@@ -1,132 +0,0 @@
-package params
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestBind_RequiredFieldsPresent(t *testing.T) {
-	type args struct {
-		Owner string `json:"owner" required:"true"`
-		Repo  string `json:"repo" required:"true"`
-	}
-	var out args
-	err := Bind(map[string]any{"owner": "gitea", "repo": "gitea-mcp"}, &out)
-	if err != nil {
-		t.Fatalf("Bind() unexpected error = %v", err)
-	}
-	if out.Owner != "gitea" || out.Repo != "gitea-mcp" {
-		t.Errorf("Bind() = %+v, want Owner=gitea Repo=gitea-mcp", out)
-	}
-}
-
-func TestBind_RequiredFieldMissing(t *testing.T) {
-	type args struct {
-		Owner string `json:"owner" required:"true"`
-	}
-	var out args
-	err := Bind(map[string]any{}, &out)
-	if err == nil {
-		t.Fatal("Bind() expected error, got nil")
-	}
-	if !strings.Contains(err.Error(), "owner") {
-		t.Errorf("Bind() error = %v, want mentioning %q", err, "owner")
-	}
-}
-
-func TestBind_RequiredStringFieldEmpty(t *testing.T) {
-	type args struct {
-		Owner string `json:"owner" required:"true"`
-	}
-	var out args
-	err := Bind(map[string]any{"owner": ""}, &out)
-	if err == nil {
-		t.Fatal("Bind() expected error for empty required string, got nil")
-	}
-}
-
-func TestBind_OptionalFieldDefaultsToZeroValue(t *testing.T) {
-	type args struct {
-		Owner     string `json:"owner" required:"true"`
-		OldBranch string `json:"old_branch"`
-	}
-	var out args
-	err := Bind(map[string]any{"owner": "gitea"}, &out)
-	if err != nil {
-		t.Fatalf("Bind() unexpected error = %v", err)
-	}
-	if out.OldBranch != "" {
-		t.Errorf("Bind() OldBranch = %q, want empty", out.OldBranch)
-	}
-}
-
-func TestBind_NumericConversion(t *testing.T) {
-	type args struct {
-		Page    int   `json:"page"`
-		PerPage int64 `json:"per_page"`
-	}
-	var out args
-	err := Bind(map[string]any{"page": float64(2), "per_page": float64(40)}, &out)
-	if err != nil {
-		t.Fatalf("Bind() unexpected error = %v", err)
-	}
-	if out.Page != 2 || out.PerPage != 40 {
-		t.Errorf("Bind() = %+v, want Page=2 PerPage=40", out)
-	}
-}
-
-func TestBind_Boolean(t *testing.T) {
-	type args struct {
-		Recursive bool `json:"recursive"`
-	}
-	var out args
-	err := Bind(map[string]any{"recursive": true}, &out)
-	if err != nil {
-		t.Fatalf("Bind() unexpected error = %v", err)
-	}
-	if !out.Recursive {
-		t.Errorf("Bind() Recursive = false, want true")
-	}
-}
-
-func TestBind_Array(t *testing.T) {
-	type args struct {
-		Labels []string `json:"labels"`
-		IDs    []int64  `json:"ids"`
-	}
-	var out args
-	err := Bind(map[string]any{
-		"labels": []any{"bug", "help wanted"},
-		"ids":    []any{float64(1), float64(2)},
-	}, &out)
-	if err != nil {
-		t.Fatalf("Bind() unexpected error = %v", err)
-	}
-	if len(out.Labels) != 2 || out.Labels[0] != "bug" || out.Labels[1] != "help wanted" {
-		t.Errorf("Bind() Labels = %v, want [bug help wanted]", out.Labels)
-	}
-	if len(out.IDs) != 2 || out.IDs[0] != 1 || out.IDs[1] != 2 {
-		t.Errorf("Bind() IDs = %v, want [1 2]", out.IDs)
-	}
-}
-
-func TestBind_InvalidFieldType(t *testing.T) {
-	type args struct {
-		Page int `json:"page"`
-	}
-	var out args
-	err := Bind(map[string]any{"page": "not-a-number"}, &out)
-	if err == nil {
-		t.Fatal("Bind() expected error for invalid numeric field, got nil")
-	}
-}
-
-func TestBind_NonPointerRejected(t *testing.T) {
-	type args struct {
-		Owner string `json:"owner"`
-	}
-	err := Bind(map[string]any{}, args{})
-	if err == nil {
-		t.Fatal("Bind() expected error for non-pointer out, got nil")
-	}
-}