test(label,milestone): cover tool registration and handler paths

Add operation/label/label_test.go verifying the label_read/label_write tools register under the "label" scope with the expected method enums and read/write classification, plus httptest coverage for list_repo_labels and create_repo_label. Extend operation/milestone/milestone_test.go with the equivalent registration assertions and an httptest-backed list milestones test. Co-Authored-By: Codet <codet@commitgo.dev> (GPT-5-Codex)
2026-08-27 02:27:45 +00:00 · 2026-08-24 00:18:30 -07:00
7 changed files with 418 additions and 288 deletions
@@ -0,0 +1,193 @@
+package label
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"sort"
+	"sync"
+	"testing"
+
+	"gitea.com/gitea/gitea-mcp/pkg/flag"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+func Test_Tool_Registration(t *testing.T) {
+	if got := Tool.Scope(); got != "label" {
+		t.Fatalf("Scope() = %q, want %q", got, "label")
+	}
+
+	readTools := Tool.ReadTools()
+	if len(readTools) != 1 || readTools[0].Tool.Name != LabelReadToolName {
+		t.Fatalf("ReadTools() = %v, want exactly [%s]", toolNames(readTools), LabelReadToolName)
+	}
+	if !readTools[0].Tool.Annotations.ReadOnlyHint {
+		t.Fatalf("%s must be marked read-only", LabelReadToolName)
+	}
+
+	writeTools := Tool.WriteTools()
+	if len(writeTools) != 1 || writeTools[0].Tool.Name != LabelWriteToolName {
+		t.Fatalf("WriteTools() = %v, want exactly [%s]", toolNames(writeTools), LabelWriteToolName)
+	}
+	if writeTools[0].Tool.Annotations.ReadOnlyHint {
+		t.Fatalf("%s must not be marked read-only", LabelWriteToolName)
+	}
+
+	assertMethodEnum(t, LabelReadTool, []string{"list_repo_labels", "get_repo_label", "list_org_labels"})
+	assertMethodEnum(t, LabelWriteTool, []string{
+		"create_repo_label", "edit_repo_label", "delete_repo_label",
+		"create_org_label", "edit_org_label", "delete_org_label",
+	})
+}
+
+func toolNames(tools []tool.ServerTool) []string {
+	names := make([]string, len(tools))
+	for i, serverTool := range tools {
+		names[i] = serverTool.Tool.Name
+	}
+	return names
+}
+
+func assertMethodEnum(t *testing.T, definition *mcp.Tool, want []string) {
+	t.Helper()
+
+	schema, ok := definition.InputSchema.(map[string]any)
+	if !ok {
+		t.Fatalf("%s: input schema = %T, want map[string]any", definition.Name, definition.InputSchema)
+	}
+	properties, ok := schema["properties"].(map[string]any)
+	if !ok {
+		t.Fatalf("%s: properties = %T, want map[string]any", definition.Name, schema["properties"])
+	}
+	method, ok := properties["method"].(map[string]any)
+	if !ok {
+		t.Fatalf("%s: method property = %T, want map[string]any", definition.Name, properties["method"])
+	}
+	enum, ok := method["enum"].([]string)
+	if !ok {
+		t.Fatalf("%s: method enum = %T, want []string", definition.Name, method["enum"])
+	}
+
+	got := append([]string{}, enum...)
+	sort.Strings(got)
+	wantSorted := append([]string{}, want...)
+	sort.Strings(wantSorted)
+	if !reflect.DeepEqual(got, wantSorted) {
+		t.Fatalf("%s: method enum = %v, want %v", definition.Name, enum, want)
+	}
+}
+
+func Test_labelReadFn_listRepoLabels(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/labels", owner, repo):
+			_, _ = w.Write([]byte(`[{"id":1,"name":"bug","color":"ff0000","description":"a bug"}]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	withTestFlags(t, server.URL)
+
+	result, err := labelReadFn(context.Background(), map[string]any{
+		"method": "list_repo_labels",
+		"owner":  owner,
+		"repo":   repo,
+	})
+	if err != nil || result.IsError {
+		t.Fatalf("list_repo_labels err=%v result=%v", err, result)
+	}
+
+	var labels []map[string]any
+	decodeResult(t, result, &labels)
+	if len(labels) != 1 || labels[0]["name"] != "bug" {
+		t.Fatalf("unexpected labels: %v", labels)
+	}
+}
+
+func Test_labelWriteFn_createRepoLabel(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	var (
+		mu   sync.Mutex
+		body map[string]any
+	)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/api/v1/version":
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case r.URL.Path == fmt.Sprintf("/api/v1/repos/%s/%s/labels", owner, repo) && r.Method == http.MethodPost:
+			mu.Lock()
+			_ = json.NewDecoder(r.Body).Decode(&body)
+			mu.Unlock()
+			_, _ = w.Write([]byte(`{"id":7,"name":"bug","color":"ff0000","description":"a bug"}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	withTestFlags(t, server.URL)
+
+	result, err := labelWriteFn(context.Background(), map[string]any{
+		"method":      "create_repo_label",
+		"owner":       owner,
+		"repo":        repo,
+		"name":        "bug",
+		"color":       "ff0000",
+		"description": "a bug",
+	})
+	if err != nil || result.IsError {
+		t.Fatalf("create_repo_label err=%v result=%v", err, result)
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if body["name"] != "bug" || body["color"] != "ff0000" {
+		t.Fatalf("unexpected request body: %v", body)
+	}
+
+	var label map[string]any
+	decodeResult(t, result, &label)
+	if label["name"] != "bug" {
+		t.Fatalf("unexpected label: %v", label)
+	}
+}
+
+func withTestFlags(t *testing.T, host string) {
+	t.Helper()
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = host, "", "test"
+	t.Cleanup(func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion })
+}
+
+func decodeResult(t *testing.T, result *mcp.CallToolResult, out any) {
+	t.Helper()
+	if len(result.Content) != 1 {
+		t.Fatalf("result content = %v, want exactly one item", result.Content)
+	}
+	text, ok := result.Content[0].(*mcp.TextContent)
+	if !ok {
+		t.Fatalf("result content = %T, want *mcp.TextContent", result.Content[0])
+	}
+	if err := json.Unmarshal([]byte(text.Text), out); err != nil {
+		t.Fatalf("decode result: %v", err)
+	}
+}
@@ -7,14 +7,122 @@ import (
 	"maps"
 	"net/http"
 	"net/http/httptest"
+	"reflect"
+	"sort"
 	"sync"
 	"testing"

 	"gitea.com/gitea/gitea-mcp/pkg/flag"
+	"gitea.com/gitea/gitea-mcp/pkg/tool"

 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )

+func Test_Tool_Registration(t *testing.T) {
+	if got := Tool.Scope(); got != "milestone" {
+		t.Fatalf("Scope() = %q, want %q", got, "milestone")
+	}
+
+	readTools := Tool.ReadTools()
+	if len(readTools) != 1 || readTools[0].Tool.Name != MilestoneReadToolName {
+		t.Fatalf("ReadTools() = %v, want exactly [%s]", toolNames(readTools), MilestoneReadToolName)
+	}
+	if !readTools[0].Tool.Annotations.ReadOnlyHint {
+		t.Fatalf("%s must be marked read-only", MilestoneReadToolName)
+	}
+
+	writeTools := Tool.WriteTools()
+	if len(writeTools) != 1 || writeTools[0].Tool.Name != MilestoneWriteToolName {
+		t.Fatalf("WriteTools() = %v, want exactly [%s]", toolNames(writeTools), MilestoneWriteToolName)
+	}
+	if writeTools[0].Tool.Annotations.ReadOnlyHint {
+		t.Fatalf("%s must not be marked read-only", MilestoneWriteToolName)
+	}
+
+	assertMethodEnum(t, MilestoneReadTool, []string{"get", "list"})
+	assertMethodEnum(t, MilestoneWriteTool, []string{"create", "update", "edit", "delete"})
+}
+
+func toolNames(tools []tool.ServerTool) []string {
+	names := make([]string, len(tools))
+	for i, serverTool := range tools {
+		names[i] = serverTool.Tool.Name
+	}
+	return names
+}
+
+func assertMethodEnum(t *testing.T, definition *mcp.Tool, want []string) {
+	t.Helper()
+
+	schema, ok := definition.InputSchema.(map[string]any)
+	if !ok {
+		t.Fatalf("%s: input schema = %T, want map[string]any", definition.Name, definition.InputSchema)
+	}
+	properties, ok := schema["properties"].(map[string]any)
+	if !ok {
+		t.Fatalf("%s: properties = %T, want map[string]any", definition.Name, schema["properties"])
+	}
+	method, ok := properties["method"].(map[string]any)
+	if !ok {
+		t.Fatalf("%s: method property = %T, want map[string]any", definition.Name, properties["method"])
+	}
+	enum, ok := method["enum"].([]string)
+	if !ok {
+		t.Fatalf("%s: method enum = %T, want []string", definition.Name, method["enum"])
+	}
+
+	got := append([]string{}, enum...)
+	sort.Strings(got)
+	wantSorted := append([]string{}, want...)
+	sort.Strings(wantSorted)
+	if !reflect.DeepEqual(got, wantSorted) {
+		t.Fatalf("%s: method enum = %v, want %v", definition.Name, enum, want)
+	}
+}
+
+func Test_listMilestonesFn(t *testing.T) {
+	const (
+		owner = "octo"
+		repo  = "demo"
+	)
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/version":
+			_, _ = w.Write([]byte(`{"version":"1.12.0"}`))
+		case fmt.Sprintf("/api/v1/repos/%s/%s/milestones", owner, repo):
+			_, _ = w.Write([]byte(`[{"id":1,"title":"v1","state":"open"}]`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	origHost, origToken, origVersion := flag.Host, flag.Token, flag.Version
+	flag.Host, flag.Token, flag.Version = server.URL, "", "test"
+	defer func() { flag.Host, flag.Token, flag.Version = origHost, origToken, origVersion }()
+
+	result, err := listMilestonesFn(context.Background(), map[string]any{
+		"owner": owner,
+		"repo":  repo,
+	})
+	if err != nil || result.IsError {
+		t.Fatalf("list err=%v result=%v", err, result)
+	}
+
+	text, ok := result.Content[0].(*mcp.TextContent)
+	if !ok {
+		t.Fatalf("result content = %T, want *mcp.TextContent", result.Content[0])
+	}
+	var milestones []map[string]any
+	if err := json.Unmarshal([]byte(text.Text), &milestones); err != nil {
+		t.Fatalf("decode result: %v", err)
+	}
+	if len(milestones) != 1 || milestones[0]["title"] != "v1" {
+		t.Fatalf("unexpected milestones: %v", milestones)
+	}
+}
+
 func Test_milestoneWriteFn_dueOn(t *testing.T) {
 	const (
 		owner = "octo"
@@ -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))
 	}
@@ -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))
 	}
@@ -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))
 	}
@@ -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
-}
@@ -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")
-	}
-}