Skip to content

Commit ee6618e

Browse files
rfearingrfearing
authored
Combine tools
1 parent bc897a1 commit ee6618e

File tree

1 file changed

+79
-136
lines changed

1 file changed

+79
-136
lines changed

‎pkg/github/notifications.go

Lines changed: 79 additions & 136 deletions
Original file line numberDiff line numberDiff line change
@@ -127,50 +127,19 @@ func GetNotifications(getClient GetClientFn, t translations.TranslationHelperFun
127127
}
128128
}
129129

130-
// markNotificationRead creates a tool to mark a notification as read.
131-
func MarkNotificationRead(getclient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
132-
return mcp.NewTool("mark_notification_read",
133-
mcp.WithDescription(t("TOOL_MARK_NOTIFICATION_READ_DESCRIPTION", "Mark a notification as read")),
134-
mcp.WithString("threadID",
130+
// ManageNotifications creates a tool to manage notifications (mark as read, mark all as read, or mark as done).
131+
func ManageNotifications(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
132+
return mcp.NewTool("manage_notifications",
133+
mcp.WithDescription(t("TOOL_MANAGE_NOTIFICATIONS_DESCRIPTION", "Manage notifications (mark as read, mark all as read, or mark as done)")),
134+
mcp.WithString("action",
135135
mcp.Required(),
136-
mcp.Description("The ID of the notification thread"),
136+
mcp.Description("The action to perform: 'mark_read', 'mark_all_read', or 'mark_done'"),
137+
),
138+
mcp.WithString("threadID",
139+
mcp.Description("The ID of the notification thread (required for 'mark_read' and 'mark_done')"),
137140
),
138-
),
139-
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
140-
client, err := getclient(ctx)
141-
if err != nil {
142-
return nil, fmt.Errorf("failed to get GitHub client: %w", err)
143-
}
144-
145-
threadID, err := requiredParam[string](request, "threadID")
146-
if err != nil {
147-
return mcp.NewToolResultError(err.Error()), nil
148-
}
149-
150-
resp, err := client.Activity.MarkThreadRead(ctx, threadID)
151-
if err != nil {
152-
return nil, fmt.Errorf("failed to mark notification as read: %w", err)
153-
}
154-
defer func() { _ = resp.Body.Close() }()
155-
156-
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
157-
body, err := io.ReadAll(resp.Body)
158-
if err != nil {
159-
return nil, fmt.Errorf("failed to read response body: %w", err)
160-
}
161-
return mcp.NewToolResultError(fmt.Sprintf("failed to mark notification as read: %s", string(body))), nil
162-
}
163-
164-
return mcp.NewToolResultText("Notification marked as read"), nil
165-
}
166-
}
167-
168-
// MarkAllNotificationsRead creates a tool to mark all notifications as read.
169-
func MarkAllNotificationsRead(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
170-
return mcp.NewTool("mark_all_notifications_read",
171-
mcp.WithDescription(t("TOOL_MARK_ALL_NOTIFICATIONS_READ_DESCRIPTION", "Mark all notifications as read")),
172141
mcp.WithString("lastReadAt",
173-
mcp.Description("Describes the last point that notifications were checked (optional). Default: Now"),
142+
mcp.Description("Describes the last point that notifications were checked (optional, for 'mark_all_read'). Default: Now"),
174143
),
175144
),
176145
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
@@ -179,122 +148,96 @@ func MarkAllNotificationsRead(getClient GetClientFn, t translations.TranslationH
179148
return nil, fmt.Errorf("failed to get GitHub client: %w", err)
180149
}
181150

182-
lastReadAt, err := OptionalStringParam(request, "lastReadAt")
151+
action, err := requiredParam[string](request, "action")
183152
if err != nil {
184153
return mcp.NewToolResultError(err.Error()), nil
185154
}
186155

187-
var markReadOptions github.Timestamp
188-
if lastReadAt != "" {
189-
lastReadTime, err := time.Parse(time.RFC3339, lastReadAt)
156+
switch action {
157+
case "mark_read":
158+
threadID, err := requiredParam[string](request, "threadID")
190159
if err != nil {
191-
return mcp.NewToolResultError(fmt.Sprintf("invalid lastReadAt time format, should be RFC3339/ISO8601: %v", err)), nil
192-
}
193-
markReadOptions = github.Timestamp{
194-
Time: lastReadTime,
160+
return mcp.NewToolResultError(err.Error()), nil
195161
}
196-
}
197-
198-
resp, err := client.Activity.MarkNotificationsRead(ctx, markReadOptions)
199-
if err != nil {
200-
return nil, fmt.Errorf("failed to mark all notifications as read: %w", err)
201-
}
202-
defer func() { _ = resp.Body.Close() }()
203162

204-
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
205-
body, err := io.ReadAll(resp.Body)
163+
resp, err := client.Activity.MarkThreadRead(ctx, threadID)
206164
if err != nil {
207-
return nil, fmt.Errorf("failed to read response body: %w", err)
165+
return nil, fmt.Errorf("failed to mark notification as read: %w", err)
166+
}
167+
defer func() { _ = resp.Body.Close() }()
168+
169+
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
170+
body, err := io.ReadAll(resp.Body)
171+
if err != nil {
172+
return nil, fmt.Errorf("failed to read response body: %w", err)
173+
}
174+
return mcp.NewToolResultError(fmt.Sprintf("failed to mark notification as read: %s", string(body))), nil
208175
}
209-
return mcp.NewToolResultError(fmt.Sprintf("failed to mark all notifications as read: %s", string(body))), nil
210-
}
211-
212-
return mcp.NewToolResultText("All notifications marked as read"), nil
213-
}
214-
}
215-
216-
// GetNotificationThread creates a tool to get a specific notification thread.
217-
func GetNotificationThread(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
218-
return mcp.NewTool("get_notification_thread",
219-
mcp.WithDescription(t("TOOL_GET_NOTIFICATION_THREAD_DESCRIPTION", "Get a specific notification thread")),
220-
mcp.WithString("threadID",
221-
mcp.Required(),
222-
mcp.Description("The ID of the notification thread"),
223-
),
224-
),
225-
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
226-
client, err := getClient(ctx)
227-
if err != nil {
228-
return nil, fmt.Errorf("failed to get GitHub client: %w", err)
229-
}
230-
231-
threadID, err := requiredParam[string](request, "threadID")
232-
if err != nil {
233-
return mcp.NewToolResultError(err.Error()), nil
234-
}
235176

236-
thread, resp, err := client.Activity.GetThread(ctx, threadID)
237-
if err != nil {
238-
return nil, fmt.Errorf("failed to get notification thread: %w", err)
239-
}
240-
defer func() { _ = resp.Body.Close() }()
177+
return mcp.NewToolResultText("Notification marked as read"), nil
241178

242-
if resp.StatusCode != http.StatusOK {
243-
body, err := io.ReadAll(resp.Body)
179+
case "mark_done":
180+
threadIDStr, err := requiredParam[string](request, "threadID")
244181
if err != nil {
245-
return nil, fmt.Errorf("failed to read response body: %w", err)
182+
return mcp.NewToolResultError(err.Error()), nil
246183
}
247-
return mcp.NewToolResultError(fmt.Sprintf("failed to get notification thread: %s", string(body))), nil
248-
}
249-
250-
r, err := json.Marshal(thread)
251-
if err != nil {
252-
return nil, fmt.Errorf("failed to marshal response: %w", err)
253-
}
254184

255-
return mcp.NewToolResultText(string(r)), nil
256-
}
257-
}
185+
threadID, err := strconv.ParseInt(threadIDStr, 10, 64)
186+
if err != nil {
187+
return mcp.NewToolResultError("Invalid threadID: must be a numeric value"), nil
188+
}
258189

259-
// markNotificationDone creates a tool to mark a notification as done.
260-
func MarkNotificationDone(getclient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {
261-
return mcp.NewTool("mark_notification_done",
262-
mcp.WithDescription(t("TOOL_MARK_NOTIFICATION_DONE_DESCRIPTION", "Mark a notification as done")),
263-
mcp.WithString("threadID",
264-
mcp.Required(),
265-
mcp.Description("The ID of the notification thread"),
266-
),
267-
),
268-
func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
269-
client, err := getclient(ctx)
270-
if err != nil {
271-
return nil, fmt.Errorf("failed to get GitHub client: %w", err)
272-
}
190+
resp, err := client.Activity.MarkThreadDone(ctx, threadID)
191+
if err != nil {
192+
return nil, fmt.Errorf("failed to mark notification as done: %w", err)
193+
}
194+
defer func() { _ = resp.Body.Close() }()
195+
196+
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
197+
body, err := io.ReadAll(resp.Body)
198+
if err != nil {
199+
return nil, fmt.Errorf("failed to read response body: %w", err)
200+
}
201+
return mcp.NewToolResultError(fmt.Sprintf("failed to mark notification as done: %s", string(body))), nil
202+
}
273203

274-
threadIDStr, err := requiredParam[string](request, "threadID")
275-
if err != nil {
276-
return mcp.NewToolResultError(err.Error()), nil
277-
}
204+
return mcp.NewToolResultText("Notification marked as done"), nil
278205

279-
threadID, err := strconv.ParseInt(threadIDStr, 10, 64)
280-
if err != nil {
281-
return mcp.NewToolResultError("Invalid threadID: must be a numeric value"), nil
282-
}
206+
case "mark_all_read":
207+
lastReadAt, err := OptionalStringParam(request, "lastReadAt")
208+
if err != nil {
209+
return mcp.NewToolResultError(err.Error()), nil
210+
}
283211

284-
resp, err := client.Activity.MarkThreadDone(ctx, threadID)
285-
if err != nil {
286-
return nil, fmt.Errorf("failed to mark notification as done: %w", err)
287-
}
288-
defer func() { _ = resp.Body.Close() }()
212+
var markReadOptions github.Timestamp
213+
if lastReadAt != "" {
214+
lastReadTime, err := time.Parse(time.RFC3339, lastReadAt)
215+
if err != nil {
216+
return mcp.NewToolResultError(fmt.Sprintf("invalid lastReadAt time format, should be RFC3339/ISO8601: %v", err)), nil
217+
}
218+
markReadOptions = github.Timestamp{
219+
Time: lastReadTime,
220+
}
221+
}
289222

290-
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
291-
body, err := io.ReadAll(resp.Body)
223+
resp, err := client.Activity.MarkNotificationsRead(ctx, markReadOptions)
292224
if err != nil {
293-
return nil, fmt.Errorf("failed to read response body: %w", err)
225+
return nil, fmt.Errorf("failed to mark all notifications as read: %w", err)
294226
}
295-
return mcp.NewToolResultError(fmt.Sprintf("failed to mark notification as done: %s", string(body))), nil
296-
}
227+
defer func() { _ = resp.Body.Close() }()
228+
229+
if resp.StatusCode != http.StatusResetContent && resp.StatusCode != http.StatusOK {
230+
body, err := io.ReadAll(resp.Body)
231+
if err != nil {
232+
return nil, fmt.Errorf("failed to read response body: %w", err)
233+
}
234+
return mcp.NewToolResultError(fmt.Sprintf("failed to mark all notifications as read: %s", string(body))), nil
235+
}
236+
237+
return mcp.NewToolResultText("All notifications marked as read"), nil
297238

298-
return mcp.NewToolResultText("Notification marked as done"), nil
239+
default:
240+
return mcp.NewToolResultError("Invalid action: must be 'mark_read', 'mark_all_read', or 'mark_done'"), nil
241+
}
299242
}
300243
}

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy