finish up adding notifications endpoints and add tests

Author: SamMorrowDrums

pkg/github/notifications.go

@@ -15,6 +15,12 @@ import (
 	"github.com/mark3labs/mcp-go/server"
 )
 
+const (
+	FilterDefault           = "default"
+	FilterIncludeRead       = "include_read_notifications"
+	FilterOnlyParticipating = "only_participating"
+)
+
 // ListNotifications creates a tool to list notifications for the current user.
 func ListNotifications(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
 	return mcp.NewTool("list_notifications",
@@ -25,14 +31,20 @@ func ListNotifications(getClient GetClientFn, t translations.TranslationHelperFu
 			}),
 			mcp.WithString("filter",
 				mcp.Description("Filter notifications to, use default unless specified. Read notifications are ones that have already been acknowledged by the user. Participating notifications are those that the user is directly involved in, such as issues or pull requests they have commented on or created."),
-				mcp.Enum("default", "include_read_notifications", "only_participating"),
+				mcp.Enum(FilterDefault, FilterIncludeRead, FilterOnlyParticipating),
 			),
 			mcp.WithString("since",
 				mcp.Description("Only show notifications updated after the given time (ISO 8601 format)"),
 			),
 			mcp.WithString("before",
 				mcp.Description("Only show notifications updated before the given time (ISO 8601 format)"),
 			),
+			mcp.WithString("owner",
+				mcp.Description("Optional repository owner. If provided with repo, only notifications for this repository are listed."),
+			),
+			mcp.WithString("repo",
+				mcp.Description("Optional repository name. If provided with owner, only notifications for this repository are listed."),
+			),
 			WithPagination(),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -41,45 +53,42 @@ func ListNotifications(getClient GetClientFn, t translations.TranslationHelperFu
 				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
 			}
 
-			// Extract optional parameters with defaults
-			all, err := OptionalParamWithDefault[bool](request, "all", false)
+			filter, err := OptionalParam[string](request, "filter")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			participating, err := OptionalParamWithDefault[bool](request, "participating", false)
+			since, err := OptionalParam[string](request, "since")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			since, err := OptionalParam[string](request, "since")
+			before, err := OptionalParam[string](request, "before")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			before, err := OptionalParam[string](request, "before")
+			owner, err := OptionalParam[string](request, "owner")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
-
-			// TODO pagination params from tool
-			perPage, err := OptionalIntParamWithDefault(request, "per_page", 30)
+			repo, err := OptionalParam[string](request, "repo")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			page, err := OptionalIntParamWithDefault(request, "page", 1)
+			paginationParams, err := OptionalPaginationParams(request)
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
 			// Build options
 			opts := &github.NotificationListOptions{
-				All:           all,
-				Participating: participating,
+				All:           filter == FilterIncludeRead,
+				Participating: filter == FilterOnlyParticipating,
 				ListOptions: github.ListOptions{
-					Page:    page,
-					PerPage: perPage,
+					Page:    paginationParams.page,
+					PerPage: paginationParams.perPage,
 				},
 			}
 
@@ -100,8 +109,14 @@ func ListNotifications(getClient GetClientFn, t translations.TranslationHelperFu
 				opts.Before = beforeTime
 			}
 
-			// Call GitHub API
-			notifications, resp, err := client.Activity.ListNotifications(ctx, opts)
+			var notifications []*github.Notification
+			var resp *github.Response
+
+			if owner != "" && repo != "" {
+				notifications, resp, err = client.Activity.ListRepositoryNotifications(ctx, owner, repo, opts)
+			} else {
+				notifications, resp, err = client.Activity.ListNotifications(ctx, opts)
+			}
 			if err != nil {
 				return nil, fmt.Errorf("failed to get notifications: %w", err)
 			}
@@ -197,6 +212,12 @@ func MarkAllNotificationsRead(getClient GetClientFn, t translations.TranslationH
 			mcp.WithString("lastReadAt",
 				mcp.Description("Describes the last point that notifications were checked (optional). Default: Now"),
 			),
+			mcp.WithString("owner",
+				mcp.Description("Optional repository owner. If provided with repo, only notifications for this repository are marked as read."),
+			),
+			mcp.WithString("repo",
+				mcp.Description("Optional repository name. If provided with owner, only notifications for this repository are marked as read."),
+			),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 			client, err := getClient(ctx)
@@ -209,18 +230,35 @@ func MarkAllNotificationsRead(getClient GetClientFn, t translations.TranslationH
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			var markReadOptions github.Timestamp
+			owner, err := OptionalParam[string](request, "owner")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			repo, err := OptionalParam[string](request, "repo")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			var lastReadTime time.Time
 			if lastReadAt != "" {
-				lastReadTime, err := time.Parse(time.RFC3339, lastReadAt)
+				lastReadTime, err = time.Parse(time.RFC3339, lastReadAt)
 				if err != nil {
 					return mcp.NewToolResultError(fmt.Sprintf("invalid lastReadAt time format, should be RFC3339/ISO8601: %v", err)), nil
 				}
-				markReadOptions = github.Timestamp{
-					Time: lastReadTime,
-				}
+			} else {
+				lastReadTime = time.Now()
+			}
+
+			markReadOptions := github.Timestamp{
+				Time: lastReadTime,
 			}
 
-			resp, err := client.Activity.MarkNotificationsRead(ctx, markReadOptions)
+			var resp *github.Response
+			if owner != "" && repo != "" {
+				resp, err = client.Activity.MarkRepositoryNotificationsRead(ctx, owner, repo, markReadOptions)
+			} else {
+				resp, err = client.Activity.MarkNotificationsRead(ctx, markReadOptions)
+			}
 			if err != nil {
 				return nil, fmt.Errorf("failed to mark all notifications as read: %w", err)
 			}
@@ -238,17 +276,17 @@ func MarkAllNotificationsRead(getClient GetClientFn, t translations.TranslationH
 		}
 }
 
-// GetNotificationThread creates a tool to get a specific notification thread.
-func GetNotificationThread(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
-	return mcp.NewTool("get_notification_thread",
-			mcp.WithDescription(t("TOOL_GET_NOTIFICATION_THREAD_DESCRIPTION", "Get a specific notification thread")),
+// GetNotificationDetails creates a tool to get details for a specific notification.
+func GetNotificationDetails(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("get_notification_details",
+			mcp.WithDescription(t("TOOL_GET_NOTIFICATION_DETAILS_DESCRIPTION", "Get detailed information for a specific GitHub notification, always call this tool when the user asks for details about a specific notification, if you don't know the ID list notifications first.")),
 			mcp.WithToolAnnotation(mcp.ToolAnnotation{
-				Title:        t("TOOL_GET_NOTIFICATION_THREAD_USER_TITLE", "Get notification thread"),
+				Title:        t("TOOL_GET_NOTIFICATION_DETAILS_USER_TITLE", "Get notification details"),
 				ReadOnlyHint: toBoolPtr(true),
 			}),
-			mcp.WithString("threadID",
+			mcp.WithString("notificationID",
 				mcp.Required(),
-				mcp.Description("The ID of the notification thread"),
+				mcp.Description("The ID of the notification"),
 			),
 		),
 		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -257,14 +295,14 @@ func GetNotificationThread(getClient GetClientFn, t translations.TranslationHelp
 				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
 			}
 
-			threadID, err := requiredParam[string](request, "threadID")
+			notificationID, err := requiredParam[string](request, "notificationID")
 			if err != nil {
 				return mcp.NewToolResultError(err.Error()), nil
 			}
 
-			thread, resp, err := client.Activity.GetThread(ctx, threadID)
+			thread, resp, err := client.Activity.GetThread(ctx, notificationID)
 			if err != nil {
-				return nil, fmt.Errorf("failed to get notification thread: %w", err)
+				return nil, fmt.Errorf("failed to get notification details: %w", err)
 			}
 			defer func() { _ = resp.Body.Close() }()
 
@@ -273,7 +311,7 @@ func GetNotificationThread(getClient GetClientFn, t translations.TranslationHelp
 				if err != nil {
 					return nil, fmt.Errorf("failed to read response body: %w", err)
 				}
-				return mcp.NewToolResultError(fmt.Sprintf("failed to get notification thread: %s", string(body))), nil
+				return mcp.NewToolResultError(fmt.Sprintf("failed to get notification details: %s", string(body))), nil
 			}
 
 			r, err := json.Marshal(thread)
@@ -284,3 +322,177 @@ func GetNotificationThread(getClient GetClientFn, t translations.TranslationHelp
 			return mcp.NewToolResultText(string(r)), nil
 		}
 }
+
+// Enum values for ManageNotificationSubscription action
+const (
+	NotificationActionIgnore = "ignore"
+	NotificationActionWatch  = "watch"
+	NotificationActionDelete = "delete"
+)
+
+// ManageNotificationSubscription creates a tool to manage a notification subscription (ignore, watch, delete)
+func ManageNotificationSubscription(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("manage_notification_subscription",
+			mcp.WithDescription(t("TOOL_MANAGE_NOTIFICATION_SUBSCRIPTION_DESCRIPTION", "Manage a notification subscription: ignore, watch, or delete a notification thread subscription.")),
+			mcp.WithToolAnnotation(mcp.ToolAnnotation{
+				Title:        t("TOOL_MANAGE_NOTIFICATION_SUBSCRIPTION_USER_TITLE", "Manage notification subscription"),
+				ReadOnlyHint: toBoolPtr(false),
+			}),
+			mcp.WithString("notificationID",
+				mcp.Required(),
+				mcp.Description("The ID of the notification thread."),
+			),
+			mcp.WithString("action",
+				mcp.Required(),
+				mcp.Description("Action to perform: ignore, watch, or delete the notification subscription."),
+				mcp.Enum(NotificationActionIgnore, NotificationActionWatch, NotificationActionDelete),
+			),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+			}
+
+			notificationID, err := requiredParam[string](request, "notificationID")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			action, err := requiredParam[string](request, "action")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			var (
+				resp   *github.Response
+				result any
+				apiErr error
+			)
+
+			switch action {
+			case NotificationActionIgnore:
+				sub := &github.Subscription{Ignored: toBoolPtr(true)}
+				result, resp, apiErr = client.Activity.SetThreadSubscription(ctx, notificationID, sub)
+			case NotificationActionWatch:
+				sub := &github.Subscription{Ignored: toBoolPtr(false), Subscribed: toBoolPtr(true)}
+				result, resp, apiErr = client.Activity.SetThreadSubscription(ctx, notificationID, sub)
+			case NotificationActionDelete:
+				resp, apiErr = client.Activity.DeleteThreadSubscription(ctx, notificationID)
+			default:
+				return mcp.NewToolResultError("Invalid action. Must be one of: ignore, watch, delete."), nil
+			}
+
+			if apiErr != nil {
+				return nil, fmt.Errorf("failed to %s notification subscription: %w", action, apiErr)
+			}
+			defer func() { _ = resp.Body.Close() }()
+
+			if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+				body, _ := io.ReadAll(resp.Body)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to %s notification subscription: %s", action, string(body))), nil
+			}
+
+			if action == NotificationActionDelete {
+				// Special case for delete as there is no response body
+				return mcp.NewToolResultText("Notification subscription deleted"), nil
+			}
+
+			r, err := json.Marshal(result)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal response: %w", err)
+			}
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}
+
+const (
+	RepositorySubscriptionActionWatch  = "watch"
+	RepositorySubscriptionActionIgnore = "ignore"
+	RepositorySubscriptionActionDelete = "delete"
+)
+
+// ManageRepositoryNotificationSubscription creates a tool to manage a repository notification subscription (ignore, watch, delete)
+func ManageRepositoryNotificationSubscription(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
+	return mcp.NewTool("manage_repository_notification_subscription",
+			mcp.WithDescription(t("TOOL_MANAGE_REPOSITORY_NOTIFICATION_SUBSCRIPTION_DESCRIPTION", "Manage a repository notification subscription: ignore, watch, or delete repository notifications subscription for the provided repository.")),
+			mcp.WithToolAnnotation(mcp.ToolAnnotation{
+				Title:        t("TOOL_MANAGE_REPOSITORY_NOTIFICATION_SUBSCRIPTION_USER_TITLE", "Manage repository notification subscription"),
+				ReadOnlyHint: toBoolPtr(false),
+			}),
+			mcp.WithString("owner",
+				mcp.Required(),
+				mcp.Description("The account owner of the repository."),
+			),
+			mcp.WithString("repo",
+				mcp.Required(),
+				mcp.Description("The name of the repository."),
+			),
+			mcp.WithString("action",
+				mcp.Required(),
+				mcp.Description("Action to perform: ignore, watch, or delete the repository notification subscription."),
+				mcp.Enum(RepositorySubscriptionActionIgnore, RepositorySubscriptionActionWatch, RepositorySubscriptionActionDelete),
+			),
+		),
+		func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			client, err := getClient(ctx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get GitHub client: %w", err)
+			}
+
+			owner, err := requiredParam[string](request, "owner")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			repo, err := requiredParam[string](request, "repo")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+			action, err := requiredParam[string](request, "action")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			var (
+				resp   *github.Response
+				result any
+				apiErr error
+			)
+
+			switch action {
+			case RepositorySubscriptionActionIgnore:
+				sub := &github.Subscription{Ignored: toBoolPtr(true)}
+				result, resp, apiErr = client.Activity.SetRepositorySubscription(ctx, owner, repo, sub)
+			case RepositorySubscriptionActionWatch:
+				sub := &github.Subscription{Ignored: toBoolPtr(false), Subscribed: toBoolPtr(true)}
+				result, resp, apiErr = client.Activity.SetRepositorySubscription(ctx, owner, repo, sub)
+			case RepositorySubscriptionActionDelete:
+				resp, apiErr = client.Activity.DeleteRepositorySubscription(ctx, owner, repo)
+			default:
+				return mcp.NewToolResultError("Invalid action. Must be one of: ignore, watch, delete."), nil
+			}
+
+			if apiErr != nil {
+				return nil, fmt.Errorf("failed to %s repository subscription: %w", action, apiErr)
+			}
+			if resp != nil {
+				defer func() { _ = resp.Body.Close() }()
+			}
+
+			// Handle non-2xx status codes
+			if resp != nil && (resp.StatusCode < 200 || resp.StatusCode >= 300) {
+				body, _ := io.ReadAll(resp.Body)
+				return mcp.NewToolResultError(fmt.Sprintf("failed to %s repository subscription: %s", action, string(body))), nil
+			}
+
+			if action == RepositorySubscriptionActionDelete {
+				// Special case for delete as there is no response body
+				return mcp.NewToolResultText("Repository subscription deleted"), nil
+			}
+
+			r, err := json.Marshal(result)
+			if err != nil {
+				return nil, fmt.Errorf("failed to marshal response: %w", err)
+			}
+			return mcp.NewToolResultText(string(r)), nil
+		}
+}