refactor to make testing easier

mntlty · mntlty · commit 383c2d2f032c · 2025-04-01T19:18:50.000-07:00
diff --git a/pkg/github/repository_resource.go b/pkg/github/repository_resource.go
@@ -14,109 +14,136 @@ import (
 )
 
 // getRepositoryContent defines the resource template and handler for the Repository Content API.
-func getRepositoryContent(client *github.Client, t translations.TranslationHelperFunc) (mainTemplate mcp.ResourceTemplate, reftemplate mcp.ResourceTemplate, shaTemplate mcp.ResourceTemplate, tagTemplate mcp.ResourceTemplate, prTemplate mcp.ResourceTemplate, handler server.ResourceTemplateHandlerFunc) {
-
+func getRepositoryContent(client *github.Client, t translations.TranslationHelperFunc) (mcp.ResourceTemplate, server.ResourceTemplateHandlerFunc) {
 	return mcp.NewResourceTemplate(
 			"repo://{owner}/{repo}/contents{/path*}", // Resource template
 			t("RESOURCE_REPOSITORY_CONTENT_DESCRIPTION", "Repository Content"),
-		), mcp.NewResourceTemplate(
+		),
+		handlerFunc(client, t)
+}
+
+// getRepositoryContent defines the resource template and handler for the Repository Content API.
+func getRepositoryBranchContent(client *github.Client, t translations.TranslationHelperFunc) (mcp.ResourceTemplate, server.ResourceTemplateHandlerFunc) {
+	return mcp.NewResourceTemplate(
 			"repo://{owner}/{repo}/refs/heads/{branch}/contents{/path*}", // Resource template
 			t("RESOURCE_REPOSITORY_CONTENT_BRANCH_DESCRIPTION", "Repository Content for specific branch"),
-		), mcp.NewResourceTemplate(
+		),
+		handlerFunc(client, t)
+}
+
+// getRepositoryContent defines the resource template and handler for the Repository Content API.
+func getRepositoryCommitContent(client *github.Client, t translations.TranslationHelperFunc) (mcp.ResourceTemplate, server.ResourceTemplateHandlerFunc) {
+	return mcp.NewResourceTemplate(
 			"repo://{owner}/{repo}/sha/{sha}/contents{/path*}", // Resource template
 			t("RESOURCE_REPOSITORY_CONTENT_COMMIT_DESCRIPTION", "Repository Content for specific commit"),
-		), mcp.NewResourceTemplate(
+		),
+		handlerFunc(client, t)
+}
+
+// getRepositoryContent defines the resource template and handler for the Repository Content API.
+func getRepositoryTagContent(client *github.Client, t translations.TranslationHelperFunc) (mcp.ResourceTemplate, server.ResourceTemplateHandlerFunc) {
+	return mcp.NewResourceTemplate(
 			"repo://{owner}/{repo}/refs/tags/{tag}/contents{/path*}", // Resource template
 			t("RESOURCE_REPOSITORY_CONTENT_TAG_DESCRIPTION", "Repository Content for specific tag"),
-		), mcp.NewResourceTemplate(
+		),
+		handlerFunc(client, t)
+}
+
+// getRepositoryContent defines the resource template and handler for the Repository Content API.
+func getRepositoryPrContent(client *github.Client, t translations.TranslationHelperFunc) (mcp.ResourceTemplate, server.ResourceTemplateHandlerFunc) {
+	return mcp.NewResourceTemplate(
 			"repo://{owner}/{repo}/refs/pull/{pr_number}/head/contents{/path*}", // Resource template
 			t("RESOURCE_REPOSITORY_CONTENT_PR_DESCRIPTION", "Repository Content for specific pull request"),
-		), func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
-			// Extract parameters from request.Params.URI
+		),
+		handlerFunc(client, t)
+}
 
-			owner := request.Params.Arguments["owner"].([]string)[0]
-			repo := request.Params.Arguments["repo"].([]string)[0]
-			// path should be a joined list of the path parts
-			path := strings.Join(request.Params.Arguments["path"].([]string), "/")
+func handlerFunc(client *github.Client, _ translations.TranslationHelperFunc) func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
+	return func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) { // Extract parameters from request.Params.URI
 
-			opts := &github.RepositoryContentGetOptions{}
+		owner := request.Params.Arguments["owner"].([]string)[0]
+		repo := request.Params.Arguments["repo"].([]string)[0]
+		// path should be a joined list of the path parts
+		path := strings.Join(request.Params.Arguments["path"].([]string), "/")
 
-			sha, ok := request.Params.Arguments["sha"].([]string)
-			if ok {
-				opts.Ref = sha[0]
-			}
+		opts := &github.RepositoryContentGetOptions{}
 
-			branch, ok := request.Params.Arguments["branch"].([]string)
-			if ok {
-				opts.Ref = "refs/heads/" + branch[0]
-			}
+		sha, ok := request.Params.Arguments["sha"].([]string)
+		if ok {
+			opts.Ref = sha[0]
+		}
 
-			tag, ok := request.Params.Arguments["tag"].([]string)
-			if ok {
-				opts.Ref = "refs/tags/" + tag[0]
-			}
-			prNumber, ok := request.Params.Arguments["pr_number"].([]string)
-			if ok {
-				opts.Ref = "refs/pull/" + prNumber[0] + "/head"
-			}
+		branch, ok := request.Params.Arguments["branch"].([]string)
+		if ok {
+			opts.Ref = "refs/heads/" + branch[0]
+		}
+
+		tag, ok := request.Params.Arguments["tag"].([]string)
+		if ok {
+			opts.Ref = "refs/tags/" + tag[0]
+		}
+		prNumber, ok := request.Params.Arguments["pr_number"].([]string)
+		if ok {
+			opts.Ref = "refs/pull/" + prNumber[0] + "/head"
+		}
+
+		// Use the GitHub client to fetch repository content
+		fileContent, directoryContent, _, err := client.Repositories.GetContents(ctx, owner, repo, path, opts)
+		if err != nil {
+			return nil, err
+		}
+
+		if directoryContent != nil {
+			// Process the directory content and return it as resource contents
+			var resources []mcp.ResourceContents
+			for _, entry := range directoryContent {
+				mimeType := "text/directory"
+				if entry.GetType() == "file" {
+					mimeType = mime.TypeByExtension(filepath.Ext(entry.GetName()))
+				}
+				resources = append(resources, mcp.TextResourceContents{
+					URI:      entry.GetHTMLURL(),
+					MIMEType: mimeType,
+					Text:     entry.GetName(),
+				})
 
-			// Use the GitHub client to fetch repository content
-			fileContent, directoryContent, _, err := client.Repositories.GetContents(ctx, owner, repo, path, opts)
-			if err != nil {
-				return nil, err
 			}
+			return resources, nil
 
-			if directoryContent != nil {
-				// Process the directory content and return it as resource contents
-				var resources []mcp.ResourceContents
-				for _, entry := range directoryContent {
-					mimeType := "text/directory"
-					if entry.GetType() == "file" {
-						mimeType = mime.TypeByExtension(filepath.Ext(entry.GetName()))
-					}
-					resources = append(resources, mcp.TextResourceContents{
-						URI:      entry.GetHTMLURL(),
-						MIMEType: mimeType,
-						Text:     entry.GetName(),
-					})
+		} else if fileContent != nil {
+			// Process the file content and return it as a binary resource
 
+			if fileContent.Content != nil {
+				decodedContent, err := fileContent.GetContent()
+				if err != nil {
+					return nil, err
 				}
-				return resources, nil
-
-			} else if fileContent != nil {
-				// Process the file content and return it as a binary resource
-
-				if fileContent.Content != nil {
-					decodedContent, err := fileContent.GetContent()
-					if err != nil {
-						return nil, err
-					}
-
-					mimeType := mime.TypeByExtension(filepath.Ext(fileContent.GetName()))
-
-					// Check if the file is text-based
-					if strings.HasPrefix(mimeType, "text") {
-						// Return as TextResourceContents
-						return []mcp.ResourceContents{
-							mcp.TextResourceContents{
-								URI:      request.Params.URI,
-								MIMEType: mimeType,
-								Text:     decodedContent,
-							},
-						}, nil
-					}
-
-					// Otherwise, return as BlobResourceContents
+
+				mimeType := mime.TypeByExtension(filepath.Ext(fileContent.GetName()))
+
+				// Check if the file is text-based
+				if strings.HasPrefix(mimeType, "text") {
+					// Return as TextResourceContents
 					return []mcp.ResourceContents{
-						mcp.BlobResourceContents{
+						mcp.TextResourceContents{
 							URI:      request.Params.URI,
 							MIMEType: mimeType,
-							Blob:     base64.StdEncoding.EncodeToString([]byte(decodedContent)), // Encode content as Base64
+							Text:     decodedContent,
 						},
 					}, nil
 				}
-			}
 
-			return nil, nil
+				// Otherwise, return as BlobResourceContents
+				return []mcp.ResourceContents{
+					mcp.BlobResourceContents{
+						URI:      request.Params.URI,
+						MIMEType: mimeType,
+						Blob:     base64.StdEncoding.EncodeToString([]byte(decodedContent)), // Encode content as Base64
+					},
+				}, nil
+			}
 		}
+
+		return nil, nil
+	}
 }
diff --git a/pkg/github/server.go b/pkg/github/server.go
@@ -25,13 +25,11 @@ func NewServer(client *github.Client, readOnly bool, t translations.TranslationH
 		server.WithLogging())
 
 	// Add GitHub Resources
-	defaultTemplate, branchTemplate, tagTemplate, shaTemplate, prTemplate, handler := getRepositoryContent(client, t)
-
-	s.AddResourceTemplate(defaultTemplate, handler)
-	s.AddResourceTemplate(branchTemplate, handler)
-	s.AddResourceTemplate(tagTemplate, handler)
-	s.AddResourceTemplate(shaTemplate, handler)
-	s.AddResourceTemplate(prTemplate, handler)
+	s.AddResourceTemplate(getRepositoryContent(client, t))
+	s.AddResourceTemplate(getRepositoryBranchContent(client, t))
+	s.AddResourceTemplate(getRepositoryCommitContent(client, t))
+	s.AddResourceTemplate(getRepositoryTagContent(client, t))
+	s.AddResourceTemplate(getRepositoryPrContent(client, t))
 
 	// Add GitHub tools - Issues
 	s.AddTool(getIssue(client, t))
