wolfpack-mcp 1.0.45 → 1.0.47

package/dist/client.js

@@ -509,6 +509,65 @@ export class WolfpackClient {
             throw error;
         }
     }
+    // Notification methods
+    async listNotifications(options) {
+        const params = new URLSearchParams();
+        if (options?.unreadOnly)
+            params.append('unreadOnly', 'true');
+        if (options?.limit)
+            params.append('limit', options.limit.toString());
+        if (options?.offset)
+            params.append('offset', options.offset.toString());
+        const query = params.toString();
+        return this.api.get(`/notifications${query ? `?${query}` : ''}`);
+    }
+    async markNotificationRead(notificationId) {
+        return this.api.put(`/notifications/${notificationId}/read`, {});
+    }
+    async markAllNotificationsRead() {
+        return this.api.put('/notifications/read-all', {});
+    }
+    async deleteNotification(notificationId) {
+        await this.api.delete(`/notifications/${notificationId}`);
+        return { message: 'Notification deleted' };
+    }
+    // Subscription methods
+    async listSubscriptions(options) {
+        const params = new URLSearchParams();
+        if (options?.documentType)
+            params.append('documentType', options.documentType);
+        if (options?.isActive !== undefined)
+            params.append('isActive', options.isActive.toString());
+        const query = params.toString();
+        return this.api.get(`/subscriptions${query ? `?${query}` : ''}`);
+    }
+    async subscribe(data) {
+        return this.api.post('/subscriptions', data);
+    }
+    async unsubscribe(documentType, documentId) {
+        return this.api.post(`/subscriptions/${documentType}/${documentId}/unsubscribe`, {});
+    }
+    async muteSubscription(documentType, documentId, duration) {
+        return this.api.post(`/subscriptions/${documentType}/${documentId}/mute`, {
+            duration,
+        });
+    }
+    async unmuteSubscription(documentType, documentId) {
+        return this.api.post(`/subscriptions/${documentType}/${documentId}/unmute`, {});
+    }
+    // Discussion methods
+    async getDiscussions(documentType, documentId) {
+        return this.api.get(`/discussions/${documentType}/${documentId}`);
+    }
+    async getDiscussionByComment(commentId) {
+        return this.api.get(`/discussions/by-comment/${commentId}`);
+    }
+    async addDiscussionComment(discussionId, content, parentCommentId) {
+        return this.api.post(`/discussions/${discussionId}/comments`, {
+            content,
+            parentCommentId,
+        });
+    }
     close() {
         // No cleanup needed for API client
     }

package/dist/index.js

@@ -469,6 +469,54 @@ const ListTeamMembersSchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+// Notification schemas
+const ListNotificationsSchema = z.object({
+    unread_only: z.boolean().optional().describe('If true, only return unread notifications'),
+    limit: z.number().optional().describe('Maximum number of notifications to return (default 20)'),
+    offset: z.number().optional().describe('Number of notifications to skip for pagination'),
+});
+const MarkNotificationReadSchema = z.object({
+    notification_id: z.string().describe('The ID of the notification to mark as read'),
+});
+const DeleteNotificationSchema = z.object({
+    notification_id: z.string().describe('The ID of the notification to delete'),
+});
+// Subscription schemas
+const VALID_DOCUMENT_TYPES = [
+    'wiki_page',
+    'work_item',
+    'radar_item',
+    'issue',
+    'journal',
+    'discussion',
+];
+const ListSubscriptionsSchema = z.object({
+    document_type: z.enum(VALID_DOCUMENT_TYPES).optional().describe('Filter by document type'),
+    is_active: z.boolean().optional().describe('Filter by active status'),
+});
+const SubscribeSchema = z.object({
+    document_type: z.enum(VALID_DOCUMENT_TYPES).describe('Type of document to subscribe to'),
+    document_id: z.string().describe('The ID of the document to subscribe to'),
+    reason: z.string().optional().describe('Reason for subscribing (default: "watched")'),
+    notify_on_mentions: z.boolean().optional().describe('Notify when mentioned in this document'),
+    notify_on_edits: z.boolean().optional().describe('Notify when the document is edited'),
+    notify_on_comments: z.boolean().optional().describe('Notify on new comments'),
+    notify_on_status: z.boolean().optional().describe('Notify on status changes'),
+    cooldown_minutes: z.number().optional().describe('Minimum minutes between notifications'),
+});
+const UnsubscribeSchema = z.object({
+    document_type: z.enum(VALID_DOCUMENT_TYPES).describe('Type of document to unsubscribe from'),
+    document_id: z.string().describe('The ID of the document to unsubscribe from'),
+});
+const MuteSubscriptionSchema = z.object({
+    document_type: z.enum(VALID_DOCUMENT_TYPES).describe('Type of document'),
+    document_id: z.string().describe('The ID of the document'),
+    duration: z.number().optional().describe('Duration in minutes to mute (omit for indefinite)'),
+});
+const UnmuteSubscriptionSchema = z.object({
+    document_type: z.enum(VALID_DOCUMENT_TYPES).describe('Type of document'),
+    document_id: z.string().describe('The ID of the document'),
+});
 // UUID v4 field names to remove from responses.
 // These are internal database IDs that agents should not use.
 // Agents should use refId (sequential int) or slug instead.
@@ -477,6 +525,24 @@ const UUID_FIELDS_TO_STRIP = new Set([
     'teamId', // Internal team UUID - noise for agents
     'workItemId', // Cross-reference UUID on Issues - noise
 ]);
+// Discussion schemas
+const GetDiscussionsSchema = z.object({
+    document_type: z.string().describe('Document type (e.g. "wiki", "work_item", "issue")'),
+    document_id: z.string().describe('The ID of the document'),
+});
+const GetDiscussionByCommentSchema = z.object({
+    comment_id: z
+        .string()
+        .describe('The ID of a discussion comment (e.g. from a notification sourceDocumentId)'),
+});
+const AddDiscussionCommentSchema = z.object({
+    discussion_id: z.string().describe('The ID of the discussion to comment on'),
+    content: z.string().describe('Comment content (supports markdown and @mentions)'),
+    parent_comment_id: z
+        .string()
+        .optional()
+        .describe('Parent comment ID for threaded replies (omit for top-level)'),
+});
 // Fields containing user-defined data that should never be recursively processed.
 const PASSTHROUGH_FIELDS = new Set(['formDefinition', 'formValues']);
 // Strip UUID v4 fields from response objects so agents use refId/slug instead.
@@ -1497,6 +1563,254 @@ class WolfpackMCPServer {
                         required: ['skill_name', 'resource_name'],
                     },
                 },
+                // Notification tools
+                {
+                    name: 'list_notifications',
+                    description: 'List your notifications. Returns notifications with type, title, message, read status, and linked items (work items, issues). ' +
+                        'Notification types include: mention, assignment, comment, status_change, team_invite, page_update, nomination, reaction. ' +
+                        'Use unread_only=true to see only unread notifications. Supports pagination with limit/offset.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            unread_only: {
+                                type: 'boolean',
+                                description: 'If true, only return unread notifications',
+                            },
+                            limit: {
+                                type: 'number',
+                                description: 'Maximum number of notifications to return (default 20)',
+                            },
+                            offset: {
+                                type: 'number',
+                                description: 'Number of notifications to skip for pagination',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'mark_notification_read',
+                    description: 'Mark a specific notification as read. Use this after processing a notification to prevent re-processing.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            notification_id: {
+                                type: 'string',
+                                description: 'The ID of the notification to mark as read',
+                            },
+                        },
+                        required: ['notification_id'],
+                    },
+                },
+                {
+                    name: 'mark_all_notifications_read',
+                    description: 'Mark all of your unread notifications as read.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'delete_notification',
+                    description: 'Delete a specific notification permanently.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            notification_id: {
+                                type: 'string',
+                                description: 'The ID of the notification to delete',
+                            },
+                        },
+                        required: ['notification_id'],
+                    },
+                },
+                // Subscription tools
+                {
+                    name: 'list_subscriptions',
+                    description: 'List your document subscriptions. Subscriptions control which documents you receive notifications for. ' +
+                        'Each subscription shows the document type, notification preferences (mentions, edits, comments, status), mute status, and reason for subscribing. ' +
+                        'Filter by document_type to see subscriptions for a specific type (e.g. "work_item", "issue", "wiki_page").',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                enum: ['wiki_page', 'work_item', 'radar_item', 'issue', 'journal', 'discussion'],
+                                description: 'Filter by document type',
+                            },
+                            is_active: {
+                                type: 'boolean',
+                                description: 'Filter by active status',
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'subscribe',
+                    description: 'Subscribe to a document to receive notifications about it. ' +
+                        'You can configure which notification types to receive: mentions, edits, comments, and status changes. ' +
+                        'Supported document types: wiki_page, work_item, radar_item, issue, journal, discussion.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                enum: ['wiki_page', 'work_item', 'radar_item', 'issue', 'journal', 'discussion'],
+                                description: 'Type of document to subscribe to',
+                            },
+                            document_id: {
+                                type: 'string',
+                                description: 'The ID of the document to subscribe to',
+                            },
+                            reason: {
+                                type: 'string',
+                                description: 'Reason for subscribing (default: "watched")',
+                            },
+                            notify_on_mentions: {
+                                type: 'boolean',
+                                description: 'Notify when mentioned in this document',
+                            },
+                            notify_on_edits: {
+                                type: 'boolean',
+                                description: 'Notify when the document is edited',
+                            },
+                            notify_on_comments: {
+                                type: 'boolean',
+                                description: 'Notify on new comments',
+                            },
+                            notify_on_status: {
+                                type: 'boolean',
+                                description: 'Notify on status changes',
+                            },
+                            cooldown_minutes: {
+                                type: 'number',
+                                description: 'Minimum minutes between notifications',
+                            },
+                        },
+                        required: ['document_type', 'document_id'],
+                    },
+                },
+                {
+                    name: 'unsubscribe',
+                    description: 'Unsubscribe from a document (soft delete). Stops notifications but keeps the subscription record. ' +
+                        'The subscription can be reactivated by subscribing again.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                enum: ['wiki_page', 'work_item', 'radar_item', 'issue', 'journal', 'discussion'],
+                                description: 'Type of document to unsubscribe from',
+                            },
+                            document_id: {
+                                type: 'string',
+                                description: 'The ID of the document to unsubscribe from',
+                            },
+                        },
+                        required: ['document_type', 'document_id'],
+                    },
+                },
+                {
+                    name: 'mute_subscription',
+                    description: 'Temporarily mute notifications from a subscription. The subscription remains active but notifications are silenced. ' +
+                        'Specify duration in minutes, or omit for indefinite mute. Use unmute_subscription to resume.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                enum: ['wiki_page', 'work_item', 'radar_item', 'issue', 'journal', 'discussion'],
+                                description: 'Type of document',
+                            },
+                            document_id: {
+                                type: 'string',
+                                description: 'The ID of the document',
+                            },
+                            duration: {
+                                type: 'number',
+                                description: 'Duration in minutes to mute (omit for indefinite)',
+                            },
+                        },
+                        required: ['document_type', 'document_id'],
+                    },
+                },
+                {
+                    name: 'unmute_subscription',
+                    description: 'Unmute a subscription to resume receiving notifications.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                enum: ['wiki_page', 'work_item', 'radar_item', 'issue', 'journal', 'discussion'],
+                                description: 'Type of document',
+                            },
+                            document_id: {
+                                type: 'string',
+                                description: 'The ID of the document',
+                            },
+                        },
+                        required: ['document_type', 'document_id'],
+                    },
+                },
+                // Discussion tools
+                {
+                    name: 'get_discussions',
+                    description: 'Get all discussion threads on a document (wiki page, work item, issue, etc.). ' +
+                        'Returns discussions with their full comment threads including replies.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            document_type: {
+                                type: 'string',
+                                description: 'Document type (e.g. "wiki", "work_item", "issue")',
+                            },
+                            document_id: {
+                                type: 'string',
+                                description: 'The ID of the document',
+                            },
+                        },
+                        required: ['document_type', 'document_id'],
+                    },
+                },
+                {
+                    name: 'get_discussion_by_comment',
+                    description: 'Find the full discussion thread containing a specific comment. ' +
+                        'Use this when you have a comment ID from a notification (sourceDocumentType: "discussion_comment") ' +
+                        'and need to see the full discussion context.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            comment_id: {
+                                type: 'string',
+                                description: 'The comment ID (e.g. from a notification sourceDocumentId)',
+                            },
+                        },
+                        required: ['comment_id'],
+                    },
+                },
+                {
+                    name: 'create_discussion_comment',
+                    description: 'Add a comment to a discussion thread. Supports threaded replies via parent_comment_id. ' +
+                        'Use this to respond to wiki page discussions, work item discussions, or any document discussion.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            discussion_id: {
+                                type: 'string',
+                                description: 'The ID of the discussion to comment on',
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'Comment content (supports markdown and @mentions)',
+                            },
+                            parent_comment_id: {
+                                type: 'string',
+                                description: 'Parent comment ID for threaded replies (omit for top-level)',
+                            },
+                        },
+                        required: ['discussion_id', 'content'],
+                    },
+                },
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -2190,6 +2504,120 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    // Notification handlers
+                    case 'list_notifications': {
+                        const parsed = ListNotificationsSchema.parse(args);
+                        const result = await this.client.listNotifications({
+                            unreadOnly: parsed.unread_only,
+                            limit: parsed.limit,
+                            offset: parsed.offset,
+                        });
+                        // Don't strip UUIDs — agents need notification IDs to mark as read/delete
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    case 'mark_notification_read': {
+                        const parsed = MarkNotificationReadSchema.parse(args);
+                        const result = await this.client.markNotificationRead(parsed.notification_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'mark_all_notifications_read': {
+                        const result = await this.client.markAllNotificationsRead();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'delete_notification': {
+                        const parsed = DeleteNotificationSchema.parse(args);
+                        const result = await this.client.deleteNotification(parsed.notification_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    // Subscription handlers
+                    case 'list_subscriptions': {
+                        const parsed = ListSubscriptionsSchema.parse(args);
+                        const result = await this.client.listSubscriptions({
+                            documentType: parsed.document_type,
+                            isActive: parsed.is_active,
+                        });
+                        // Don't strip UUIDs — agents need subscription IDs
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    case 'subscribe': {
+                        const parsed = SubscribeSchema.parse(args);
+                        const result = await this.client.subscribe({
+                            documentType: parsed.document_type,
+                            documentId: parsed.document_id,
+                            reason: parsed.reason,
+                            notifyOnMentions: parsed.notify_on_mentions,
+                            notifyOnEdits: parsed.notify_on_edits,
+                            notifyOnComments: parsed.notify_on_comments,
+                            notifyOnStatus: parsed.notify_on_status,
+                            cooldownMinutes: parsed.cooldown_minutes,
+                        });
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'unsubscribe': {
+                        const parsed = UnsubscribeSchema.parse(args);
+                        const result = await this.client.unsubscribe(parsed.document_type, parsed.document_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'mute_subscription': {
+                        const parsed = MuteSubscriptionSchema.parse(args);
+                        const result = await this.client.muteSubscription(parsed.document_type, parsed.document_id, parsed.duration);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'unmute_subscription': {
+                        const parsed = UnmuteSubscriptionSchema.parse(args);
+                        const result = await this.client.unmuteSubscription(parsed.document_type, parsed.document_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    // Discussion handlers
+                    case 'get_discussions': {
+                        const parsed = GetDiscussionsSchema.parse(args);
+                        const result = await this.client.getDiscussions(parsed.document_type, parsed.document_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'get_discussion_by_comment': {
+                        const parsed = GetDiscussionByCommentSchema.parse(args);
+                        const result = await this.client.getDiscussionByComment(parsed.comment_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'create_discussion_comment': {
+                        const parsed = AddDiscussionCommentSchema.parse(args);
+                        const result = await this.client.addDiscussionComment(parsed.discussion_id, parsed.content, parsed.parent_comment_id);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",