@vibescope/mcp-server 0.3.0 → 0.4.0

package/dist/api-client/blockers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Blockers API Methods
+ *
+ * Methods for blocker management:
+ * - getBlockers: List blockers for a project
+ * - addBlocker: Create a new blocker
+ * - resolveBlocker: Mark blocker as resolved
+ * - deleteBlocker: Delete a blocker
+ * - getBlockersStats: Get blocker statistics
+ */
+import type { ApiResponse, RequestFn } from './types.js';
+export interface BlockersMethods {
+    getBlockers(projectId: string, params?: {
+        status?: 'open' | 'resolved';
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        blockers: Array<{
+            id: string;
+            description: string;
+            status: string;
+            created_at: string;
+            resolved_at?: string;
+            resolution_note?: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    addBlocker(projectId: string, description: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        blocker_id: string;
+    }>>;
+    resolveBlocker(blockerId: string, resolutionNote?: string): Promise<ApiResponse<{
+        success: boolean;
+        blocker_id: string;
+    }>>;
+    deleteBlocker(blockerId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getBlockersStats(projectId: string): Promise<ApiResponse<{
+        total: number;
+        open: number;
+        resolved: number;
+    }>>;
+}
+export declare function createBlockersMethods(request: RequestFn): BlockersMethods;

package/dist/api-client/blockers.js

@@ -0,0 +1,43 @@
+/**
+ * Blockers API Methods
+ *
+ * Methods for blocker management:
+ * - getBlockers: List blockers for a project
+ * - addBlocker: Create a new blocker
+ * - resolveBlocker: Mark blocker as resolved
+ * - deleteBlocker: Delete a blocker
+ * - getBlockersStats: Get blocker statistics
+ */
+export function createBlockersMethods(request) {
+    return {
+        async getBlockers(projectId, params) {
+            const queryParams = new URLSearchParams();
+            if (params?.status)
+                queryParams.set('status', params.status);
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            if (params?.offset)
+                queryParams.set('offset', params.offset.toString());
+            const query = queryParams.toString();
+            const url = `/api/mcp/projects/${projectId}/blockers${query ? `?${query}` : ''}`;
+            return request('GET', url);
+        },
+        async addBlocker(projectId, description, sessionId) {
+            return request('POST', `/api/mcp/projects/${projectId}/blockers`, {
+                description,
+                session_id: sessionId
+            });
+        },
+        async resolveBlocker(blockerId, resolutionNote) {
+            return request('PATCH', `/api/mcp/blockers/${blockerId}/resolve`, {
+                resolution_note: resolutionNote
+            });
+        },
+        async deleteBlocker(blockerId) {
+            return request('DELETE', `/api/mcp/blockers/${blockerId}`);
+        },
+        async getBlockersStats(projectId) {
+            return request('GET', `/api/mcp/projects/${projectId}/blockers/stats`);
+        }
+    };
+}

package/dist/api-client/cost.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Cost API Methods
+ *
+ * Methods for cost tracking and alerts:
+ * - getCostSummary: Get cost summary by period
+ * - getCostAlerts: List cost alerts
+ * - addCostAlert: Create a cost alert
+ * - updateCostAlert: Update a cost alert
+ * - deleteCostAlert: Delete a cost alert
+ * - getTaskCosts: Get costs by task
+ * - getBodyOfWorkCosts: Get costs by body of work
+ * - getSprintCosts: Get costs by sprint
+ * - getTokenUsage: Get token usage stats
+ * - reportTokenUsage: Report token usage
+ */
+import type { ApiResponse, RequestFn } from './types.js';
+export interface CostMethods {
+    getCostSummary(projectId: string, params?: {
+        period?: 'daily' | 'weekly' | 'monthly';
+        limit?: number;
+    }): Promise<ApiResponse<{
+        summary: Array<{
+            period: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+            api_calls: number;
+        }>;
+    }>>;
+    getCostAlerts(): Promise<ApiResponse<{
+        alerts: Array<{
+            id: string;
+            project_id?: string;
+            threshold_amount: number;
+            threshold_period: string;
+            alert_type: string;
+            enabled: boolean;
+        }>;
+    }>>;
+    addCostAlert(params: {
+        project_id?: string;
+        threshold_amount: number;
+        threshold_period: 'daily' | 'weekly' | 'monthly';
+        alert_type?: 'warning' | 'critical';
+    }): Promise<ApiResponse<{
+        success: boolean;
+        alert_id: string;
+    }>>;
+    updateCostAlert(alertId: string, updates: {
+        threshold_amount?: number;
+        threshold_period?: 'daily' | 'weekly' | 'monthly';
+        alert_type?: 'warning' | 'critical';
+        enabled?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        alert_id: string;
+    }>>;
+    deleteCostAlert(alertId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getTaskCosts(projectId: string, limit?: number): Promise<ApiResponse<{
+        tasks: Array<{
+            task_id: string;
+            task_title: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+        }>;
+    }>>;
+    getBodyOfWorkCosts(params: {
+        body_of_work_id?: string;
+        project_id?: string;
+        limit?: number;
+    }): Promise<ApiResponse<{
+        bodies_of_work: Array<{
+            body_of_work_id: string;
+            title: string;
+            total_cost: number;
+            task_count: number;
+        }>;
+    }>>;
+    getSprintCosts(params: {
+        sprint_id?: string;
+        project_id?: string;
+        limit?: number;
+    }): Promise<ApiResponse<{
+        sprints: Array<{
+            sprint_id: string;
+            name: string;
+            total_cost: number;
+            task_count: number;
+        }>;
+    }>>;
+    getTokenUsage(): Promise<ApiResponse<{
+        session_tokens: {
+            input: number;
+            output: number;
+        };
+        estimated_cost: number;
+    }>>;
+    reportTokenUsage(sessionId: string, params: {
+        input_tokens: number;
+        output_tokens: number;
+        model?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        session_id: string;
+        total_input_tokens: number;
+        total_output_tokens: number;
+    }>>;
+}
+export declare function createCostMethods(request: RequestFn): CostMethods;

package/dist/api-client/cost.js

@@ -0,0 +1,76 @@
+/**
+ * Cost API Methods
+ *
+ * Methods for cost tracking and alerts:
+ * - getCostSummary: Get cost summary by period
+ * - getCostAlerts: List cost alerts
+ * - addCostAlert: Create a cost alert
+ * - updateCostAlert: Update a cost alert
+ * - deleteCostAlert: Delete a cost alert
+ * - getTaskCosts: Get costs by task
+ * - getBodyOfWorkCosts: Get costs by body of work
+ * - getSprintCosts: Get costs by sprint
+ * - getTokenUsage: Get token usage stats
+ * - reportTokenUsage: Report token usage
+ */
+export function createCostMethods(request) {
+    return {
+        async getCostSummary(projectId, params) {
+            const queryParams = new URLSearchParams();
+            if (params?.period)
+                queryParams.set('period', params.period);
+            if (params?.limit)
+                queryParams.set('limit', params.limit.toString());
+            const query = queryParams.toString();
+            const url = `/api/mcp/projects/${projectId}/cost-summary${query ? `?${query}` : ''}`;
+            return request('GET', url);
+        },
+        async getCostAlerts() {
+            return request('GET', '/api/mcp/cost-alerts');
+        },
+        async addCostAlert(params) {
+            return request('POST', '/api/mcp/cost-alerts', params);
+        },
+        async updateCostAlert(alertId, updates) {
+            return request('PATCH', `/api/mcp/cost-alerts/${alertId}`, updates);
+        },
+        async deleteCostAlert(alertId) {
+            return request('DELETE', `/api/mcp/cost-alerts/${alertId}`);
+        },
+        async getTaskCosts(projectId, limit) {
+            const url = limit
+                ? `/api/mcp/projects/${projectId}/task-costs?limit=${limit}`
+                : `/api/mcp/projects/${projectId}/task-costs`;
+            return request('GET', url);
+        },
+        async getBodyOfWorkCosts(params) {
+            const queryParams = new URLSearchParams();
+            if (params.body_of_work_id)
+                queryParams.set('body_of_work_id', params.body_of_work_id);
+            if (params.project_id)
+                queryParams.set('project_id', params.project_id);
+            if (params.limit)
+                queryParams.set('limit', params.limit.toString());
+            return request('GET', `/api/mcp/cost/bodies-of-work?${queryParams.toString()}`);
+        },
+        async getSprintCosts(params) {
+            const queryParams = new URLSearchParams();
+            if (params.sprint_id)
+                queryParams.set('sprint_id', params.sprint_id);
+            if (params.project_id)
+                queryParams.set('project_id', params.project_id);
+            if (params.limit)
+                queryParams.set('limit', params.limit.toString());
+            return request('GET', `/api/mcp/cost/sprints?${queryParams.toString()}`);
+        },
+        async getTokenUsage() {
+            return request('GET', '/api/mcp/sessions/token-usage');
+        },
+        async reportTokenUsage(sessionId, params) {
+            return request('POST', '/api/mcp/sessions/token-usage', {
+                session_id: sessionId,
+                ...params
+            });
+        }
+    };
+}

package/dist/api-client/decisions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Decisions API Methods
+ *
+ * Methods for decision tracking:
+ * - getDecisions: List decisions for a project
+ * - getDecision: Get a single decision
+ * - logDecision: Log a new decision
+ * - deleteDecision: Delete a decision
+ * - getDecisionsStats: Get decision statistics
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface DecisionsMethods {
+    getDecisions(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        decisions: Array<{
+            id: string;
+            title: string;
+            description: string;
+            rationale?: string;
+            alternatives_considered?: string[];
+            created_at: string;
+        }>;
+        total_count?: number;
+        has_more?: boolean;
+    }>>;
+    getDecision(decisionId: string): Promise<ApiResponse<{
+        decision: {
+            id: string;
+            title: string;
+            description: string;
+            rationale?: string;
+            alternatives_considered?: string[];
+            created_at: string;
+        };
+    }>>;
+    logDecision(projectId: string, params: {
+        title: string;
+        description: string;
+        rationale?: string;
+        alternatives_considered?: string[];
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        decision_id: string;
+    }>>;
+    deleteDecision(decisionId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getDecisionsStats(projectId: string): Promise<ApiResponse<{
+        total: number;
+    }>>;
+}
+export declare function createDecisionsMethods(proxy: ProxyFn): DecisionsMethods;

package/dist/api-client/decisions.js

@@ -0,0 +1,32 @@
+/**
+ * Decisions API Methods
+ *
+ * Methods for decision tracking:
+ * - getDecisions: List decisions for a project
+ * - getDecision: Get a single decision
+ * - logDecision: Log a new decision
+ * - deleteDecision: Delete a decision
+ * - getDecisionsStats: Get decision statistics
+ */
+export function createDecisionsMethods(proxy) {
+    return {
+        async getDecisions(projectId, options) {
+            return proxy('get_decisions', { project_id: projectId, ...options });
+        },
+        async getDecision(decisionId) {
+            return proxy('get_decision', { decision_id: decisionId });
+        },
+        async logDecision(projectId, params, sessionId) {
+            return proxy('log_decision', {
+                project_id: projectId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async deleteDecision(decisionId) {
+            return proxy('delete_decision', { decision_id: decisionId });
+        },
+        async getDecisionsStats(projectId) {
+            return proxy('get_decisions_stats', { project_id: projectId });
+        }
+    };
+}

package/dist/api-client/discovery.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Discovery API Methods
+ *
+ * Methods for knowledge and help discovery:
+ * - queryKnowledgeBase: Query aggregated project knowledge
+ * - getHelpTopic: Get help for a specific topic
+ * - getHelpTopics: List all help topics
+ */
+import type { ApiResponse, RequestFn } from './types.js';
+export interface DiscoveryMethods {
+    queryKnowledgeBase(projectId: string, params?: {
+        scope?: 'summary' | 'detailed';
+        categories?: Array<'findings' | 'qa' | 'decisions' | 'completed_tasks' | 'blockers' | 'progress'>;
+        limit?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        findings?: Array<{
+            id: string;
+            title: string;
+            category: string;
+            severity: string;
+        }>;
+        qa?: Array<{
+            id: string;
+            question: string;
+            answer?: string;
+        }>;
+        decisions?: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+        completed_tasks?: Array<{
+            id: string;
+            title: string;
+            completed_at: string;
+        }>;
+        blockers?: Array<{
+            id: string;
+            description: string;
+            status: string;
+        }>;
+        progress?: Array<{
+            id: string;
+            note: string;
+            created_at: string;
+        }>;
+    }>>;
+    getHelpTopic(slug: string): Promise<ApiResponse<{
+        topic: {
+            slug: string;
+            title: string;
+            content: string;
+        };
+    }>>;
+    getHelpTopics(): Promise<ApiResponse<Array<{
+        slug: string;
+        title: string;
+        description?: string;
+    }>>>;
+}
+export declare function createDiscoveryMethods(request: RequestFn): DiscoveryMethods;

package/dist/api-client/discovery.js

@@ -0,0 +1,21 @@
+/**
+ * Discovery API Methods
+ *
+ * Methods for knowledge and help discovery:
+ * - queryKnowledgeBase: Query aggregated project knowledge
+ * - getHelpTopic: Get help for a specific topic
+ * - getHelpTopics: List all help topics
+ */
+export function createDiscoveryMethods(request) {
+    return {
+        async queryKnowledgeBase(projectId, params) {
+            return request('POST', `/api/mcp/projects/${projectId}/knowledge`, params || {});
+        },
+        async getHelpTopic(slug) {
+            return request('GET', `/api/mcp/help/${slug}`);
+        },
+        async getHelpTopics() {
+            return request('GET', '/api/mcp/help');
+        }
+    };
+}

package/dist/api-client/ideas.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Ideas API Methods
+ *
+ * Methods for idea management:
+ * - getIdeas: List ideas for a project
+ * - getIdea: Get a single idea
+ * - addIdea: Create a new idea
+ * - updateIdea: Update an idea
+ * - deleteIdea: Delete an idea
+ * - convertIdeaToTask: Convert an idea to a task
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface IdeasMethods {
+    getIdeas(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        ideas: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            doc_url?: string;
+            created_at: string;
+        }>;
+        total_count?: number;
+        has_more?: boolean;
+    }>>;
+    getIdea(ideaId: string): Promise<ApiResponse<{
+        idea: {
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            doc_url?: string;
+            created_at: string;
+        };
+    }>>;
+    addIdea(projectId: string, params: {
+        title: string;
+        description?: string;
+        status?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    updateIdea(ideaId: string, updates: {
+        title?: string;
+        description?: string;
+        status?: string;
+        doc_url?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    deleteIdea(ideaId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    convertIdeaToTask(ideaId: string, params?: {
+        priority?: number;
+        estimated_minutes?: number;
+        update_status?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        task_id?: string;
+        task_title?: string;
+        idea_id?: string;
+        idea_status?: string;
+        message?: string;
+        error?: string;
+    }>>;
+}
+export declare function createIdeasMethods(proxy: ProxyFn): IdeasMethods;

package/dist/api-client/ideas.js

@@ -0,0 +1,36 @@
+/**
+ * Ideas API Methods
+ *
+ * Methods for idea management:
+ * - getIdeas: List ideas for a project
+ * - getIdea: Get a single idea
+ * - addIdea: Create a new idea
+ * - updateIdea: Update an idea
+ * - deleteIdea: Delete an idea
+ * - convertIdeaToTask: Convert an idea to a task
+ */
+export function createIdeasMethods(proxy) {
+    return {
+        async getIdeas(projectId, params) {
+            return proxy('get_ideas', { project_id: projectId, ...params });
+        },
+        async getIdea(ideaId) {
+            return proxy('get_idea', { idea_id: ideaId });
+        },
+        async addIdea(projectId, params, sessionId) {
+            return proxy('add_idea', {
+                project_id: projectId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async updateIdea(ideaId, updates) {
+            return proxy('update_idea', { idea_id: ideaId, ...updates });
+        },
+        async deleteIdea(ideaId) {
+            return proxy('delete_idea', { idea_id: ideaId });
+        },
+        async convertIdeaToTask(ideaId, params) {
+            return proxy('convert_idea_to_task', { idea_id: ideaId, ...params });
+        }
+    };
+}