wolfpack-mcp 1.0.0

package/dist/client.js

@@ -0,0 +1,229 @@
+import { ApiClient } from './apiClient.js';
+export class WolfpackClient {
+    api;
+    teamId = null;
+    constructor() {
+        this.api = new ApiClient();
+    }
+    /**
+     * Fetch and cache the team ID from the team slug.
+     * Uses the MCP team endpoint to get team info.
+     */
+    async resolveTeamSlug(teamSlug) {
+        try {
+            const team = await this.api.get(`/team/${teamSlug}`);
+            this.teamId = team.id;
+            return team.id;
+        }
+        catch (error) {
+            throw new Error(`Failed to resolve team slug "${teamSlug}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getTeamId() {
+        return this.teamId;
+    }
+    setTeamId(teamId) {
+        this.teamId = teamId;
+    }
+    /**
+     * List all teams the authenticated user is a member of.
+     */
+    async listTeams() {
+        return this.api.get('/teams');
+    }
+    // Work Item methods
+    async listWorkItems(options) {
+        const params = new URLSearchParams();
+        if (options?.teamId)
+            params.append('teamId', options.teamId.toString());
+        if (options?.status)
+            params.append('status', options.status);
+        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(`/work-items${query ? `?${query}` : ''}`);
+    }
+    async getWorkItem(workItemId, teamId) {
+        try {
+            const params = new URLSearchParams();
+            if (teamId)
+                params.append('teamId', teamId.toString());
+            const query = params.toString();
+            return await this.api.get(`/work-items/${workItemId}${query ? `?${query}` : ''}`);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateWorkProgress(workItemId, description) {
+        try {
+            return await this.api.put(`/work-items/${workItemId}/progress`, {
+                description,
+            });
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateWorkItemStatus(workItemId, status) {
+        try {
+            return await this.api.put(`/work-items/${workItemId}/status`, { status });
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    // Radar Item (Initiative/Roadmap) methods
+    async listRadarItems(options) {
+        const params = new URLSearchParams();
+        if (options?.teamId)
+            params.append('teamId', options.teamId.toString());
+        if (options?.stage)
+            params.append('stage', options.stage);
+        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(`/radar-items${query ? `?${query}` : ''}`);
+    }
+    async getRadarItem(itemId, teamId) {
+        try {
+            const params = new URLSearchParams();
+            if (teamId)
+                params.append('teamId', teamId.toString());
+            const query = params.toString();
+            return await this.api.get(`/radar-items/${itemId}${query ? `?${query}` : ''}`);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    // Issue methods
+    async listIssues(options) {
+        const params = new URLSearchParams();
+        if (options?.teamId)
+            params.append('teamId', options.teamId.toString());
+        if (options?.status)
+            params.append('status', options.status);
+        if (options?.severity)
+            params.append('severity', options.severity);
+        if (options?.type)
+            params.append('type', options.type);
+        if (options?.assignedToId)
+            params.append('assignedToId', options.assignedToId);
+        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(`/issues${query ? `?${query}` : ''}`);
+    }
+    async getIssue(issueId, teamId) {
+        try {
+            const params = new URLSearchParams();
+            if (teamId)
+                params.append('teamId', teamId.toString());
+            const query = params.toString();
+            return await this.api.get(`/issues/${issueId}${query ? `?${query}` : ''}`);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    // Create methods
+    async createWorkItem(data) {
+        return this.api.post('/work-items', data);
+    }
+    async createIssue(data) {
+        return this.api.post('/issues', data);
+    }
+    async updateIssue(issueId, data) {
+        return this.api.patch(`/issues/${issueId}`, data);
+    }
+    // Wiki Page methods
+    async listWikiPages(options) {
+        const params = new URLSearchParams();
+        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(`/wiki-pages${query ? `?${query}` : ''}`);
+    }
+    async getWikiPage(pageId) {
+        try {
+            return await this.api.get(`/wiki-pages/${encodeURIComponent(pageId)}`);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async createWikiPage(data) {
+        return this.api.post('/wiki-pages', data);
+    }
+    async updateWikiPage(pageId, data) {
+        return this.api.patch(`/wiki-pages/${pageId}`, data);
+    }
+    // Journal Entry methods
+    async listJournalEntries(options) {
+        const params = new URLSearchParams();
+        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(`/journal-entries${query ? `?${query}` : ''}`);
+    }
+    async getJournalEntry(entryId, teamId) {
+        try {
+            const params = new URLSearchParams();
+            if (teamId)
+                params.append('teamId', teamId.toString());
+            const query = params.toString();
+            return await this.api.get(`/journal-entries/${entryId}${query ? `?${query}` : ''}`);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async createJournalEntry(data) {
+        return this.api.post('/journal-entries', data);
+    }
+    async updateJournalEntry(entryId, data) {
+        return this.api.patch(`/journal-entries/${entryId}`, data);
+    }
+    // Comment methods
+    async createWorkItemComment(workItemId, data) {
+        return this.api.post(`/work-items/${workItemId}/comments`, data);
+    }
+    async createIssueComment(issueId, data) {
+        return this.api.post(`/issues/${issueId}/comments`, data);
+    }
+    close() {
+        // No cleanup needed for API client
+    }
+}

package/dist/config.js

@@ -0,0 +1,26 @@
+export const config = {
+    apiUrl: process.env.WOLFPACK_API_URL || 'https://wolfpacks.work/api/mcp',
+    apiKey: process.env.WOLFPACK_API_KEY,
+    teamSlug: process.env.WOLFPACK_TEAM_SLUG,
+};
+// Validate configuration on startup
+export function validateConfig() {
+    if (!config.apiKey) {
+        console.error('Error: WOLFPACK_API_KEY environment variable is required');
+        console.error('Please set WOLFPACK_API_KEY to your API key from the Wolfpack application');
+        console.error('Example: WOLFPACK_API_KEY=wfp_sk_...');
+        process.exit(1);
+    }
+    if (!config.apiKey.startsWith('wfp_sk_')) {
+        console.error('Error: Invalid API key format');
+        console.error('API keys should start with "wfp_sk_"');
+        process.exit(1);
+    }
+    console.error(`MCP Server connecting to: ${config.apiUrl}`);
+    if (config.teamSlug) {
+        console.error(`Team configured: ${config.teamSlug}`);
+    }
+    else {
+        console.error('No team configured - will auto-detect or use list_teams tool');
+    }
+}