@vibescope/mcp-server 0.3.1 → 0.3.4

package/src/api-client/cost.ts

@@ -0,0 +1,185 @@
+/**
+ * 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 function createCostMethods(request: RequestFn): CostMethods {
+	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/src/api-client/decisions.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 function createDecisionsMethods(proxy: ProxyFn): DecisionsMethods {
+	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/src/api-client/discovery.ts

@@ -0,0 +1,81 @@
+/**
+ * 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 function createDiscoveryMethods(request: RequestFn): DiscoveryMethods {
+	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/src/api-client/ideas.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 function createIdeasMethods(proxy: ProxyFn): IdeasMethods {
+	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 });
+		}
+	};
+}