@vibescope/mcp-server 0.4.3 → 0.4.5

package/src/api-client/progress.ts

@@ -0,0 +1,94 @@
+/**
+ * Progress API Methods
+ *
+ * Methods for progress tracking and activity feeds:
+ * - logProgress: Log a progress update for a project
+ * - getActivityFeed: Get combined activity feed
+ * - getActivityHistory: Get background activity history
+ * - getActivitySchedules: Get background activity schedules
+ */
+
+import type { ApiResponse, RequestFn, ProxyFn } from './types.js';
+
+export interface ProgressMethods {
+	logProgress(projectId: string, params: {
+		summary: string;
+		details?: string;
+		task_id?: string;
+		session_id?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		progress_id: string;
+	}>>;
+
+	getActivityFeed(projectId: string, params?: {
+		limit?: number;
+		since?: string;
+		types?: string[];
+		created_by?: string;
+	}): Promise<ApiResponse<{
+		activities: Array<{
+			type: string;
+			data: unknown;
+			timestamp: string;
+		}>;
+	}>>;
+
+	getActivityHistory(projectId: string, params?: {
+		activity_type?: string;
+		limit?: number;
+	}): Promise<ApiResponse<{
+		history: Array<{
+			id: string;
+			activity_type: string;
+			completed_at: string;
+			summary?: string;
+		}>;
+		latest_by_type: Record<string, unknown>;
+		count: number;
+	}>>;
+
+	getActivitySchedules(projectId: string, params?: {
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		schedules: Array<{
+			id: string;
+			activity_type: string;
+			schedule_type: string;
+			next_run_at?: string;
+			enabled: boolean;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>>;
+}
+
+export function createProgressMethods(request: RequestFn, proxy: ProxyFn): ProgressMethods {
+	return {
+		async logProgress(projectId, params) {
+			return request('POST', `/api/mcp/projects/${projectId}/progress`, params);
+		},
+
+		async getActivityFeed(projectId, params) {
+			return proxy('get_activity_feed', {
+				project_id: projectId,
+				...params
+			});
+		},
+
+		async getActivityHistory(projectId, params) {
+			return proxy('get_activity_history', {
+				project_id: projectId,
+				...params
+			});
+		},
+
+		async getActivitySchedules(projectId, params) {
+			return proxy('get_activity_schedules', {
+				project_id: projectId,
+				...params
+			});
+		}
+	};
+}

package/src/api-client/requests.ts

@@ -0,0 +1,54 @@
+/**
+ * Requests API Methods
+ *
+ * Methods for user request handling:
+ * - getPendingRequests: Get unacknowledged requests for a project
+ * - acknowledgeRequest: Mark a request as handled
+ * - answerQuestion: Answer a question from the user
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface RequestsMethods {
+	getPendingRequests(projectId: string, sessionId?: string, limit?: number, offset?: number): Promise<ApiResponse<{
+		requests: Array<{
+			id: string;
+			request_type: string;
+			message: string;
+			created_at: string;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>>;
+
+	acknowledgeRequest(requestId: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	answerQuestion(requestId: string, answer: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+}
+
+export function createRequestsMethods(proxy: ProxyFn): RequestsMethods {
+	return {
+		async getPendingRequests(projectId, sessionId, limit, offset) {
+			return proxy('get_pending_requests', {
+				project_id: projectId,
+				...(limit !== undefined && { limit }),
+				...(offset !== undefined && { offset }),
+			}, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async acknowledgeRequest(requestId, sessionId) {
+			return proxy('acknowledge_request', { request_id: requestId }, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async answerQuestion(requestId, answer, sessionId) {
+			return proxy('answer_question', {
+				request_id: requestId,
+				answer
+			}, sessionId ? { session_id: sessionId } : undefined);
+		}
+	};
+}

package/src/api-client/sprints.ts

@@ -0,0 +1,227 @@
+/**
+ * Sprints API Methods
+ *
+ * Methods for sprint management:
+ * - createSprint: Create a new sprint
+ * - updateSprint: Update sprint details
+ * - getSprint: Get a sprint with tasks
+ * - getSprints: List sprints for a project
+ * - deleteSprint: Delete a sprint
+ * - startSprint: Activate a sprint
+ * - completeSprint: Complete a sprint
+ * - addTaskToSprint: Add a task to a sprint
+ * - removeTaskFromSprint: Remove a task from a sprint
+ * - getSprintBacklog: Get tasks available to add to a sprint
+ * - getSprintVelocity: Get velocity metrics for completed sprints
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface SprintsMethods {
+	createSprint(projectId: string, params: {
+		title: string;
+		start_date: string;
+		end_date: string;
+		goal?: string;
+		auto_deploy_on_completion?: boolean;
+		deploy_environment?: string;
+		deploy_version_bump?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		sprint_id: string;
+		sprint_number: number;
+	}>>;
+
+	updateSprint(sprintId: string, updates: {
+		title?: string;
+		goal?: string;
+		start_date?: string;
+		end_date?: string;
+		auto_deploy_on_completion?: boolean;
+		deploy_environment?: string;
+		deploy_version_bump?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	getSprint(sprintId: string, summaryOnly?: boolean): Promise<ApiResponse<{
+		id: string;
+		title: string;
+		goal?: string;
+		sprint_number: number;
+		sprint_status: string;
+		start_date: string;
+		end_date: string;
+		progress_percentage: number;
+		velocity_points: number;
+		committed_points: number;
+		pre_tasks?: unknown[];
+		core_tasks?: unknown[];
+		post_tasks?: unknown[];
+		total_tasks?: number;
+		task_counts?: {
+			pre: { total: number; completed: number };
+			core: { total: number; completed: number };
+			post: { total: number; completed: number };
+			total: number;
+			completed: number;
+			in_progress: number;
+		};
+		next_task?: { id: string; title: string; priority: number; phase: string } | null;
+	}>>;
+
+	getSprints(projectId: string, params?: {
+		status?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		sprints: Array<{
+			id: string;
+			title: string;
+			sprint_number: number;
+			sprint_status: string;
+			start_date: string;
+			end_date: string;
+			progress_percentage: number;
+			velocity_points: number;
+			committed_points: number;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>>;
+
+	deleteSprint(sprintId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	startSprint(sprintId: string): Promise<ApiResponse<{
+		success: boolean;
+		sprint_id: string;
+		status: string;
+	}>>;
+
+	completeSprint(sprintId: string, params?: {
+		retrospective_notes?: string;
+		skip_retrospective?: boolean;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		sprint_id: string;
+		status: string;
+	}>>;
+
+	addTaskToSprint(sprintId: string, taskId: string, params?: {
+		story_points?: number;
+		phase?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	removeTaskFromSprint(sprintId: string, taskId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>>;
+
+	getSprintBacklog(projectId: string, sprintId?: string, params?: {
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		tasks: Array<{
+			id: string;
+			title: string;
+			priority: number;
+			status: string;
+			estimated_minutes?: number;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>>;
+
+	getSprintVelocity(projectId: string, limit?: number): Promise<ApiResponse<{
+		sprints: Array<{
+			sprint_id: string;
+			sprint_number: number;
+			title: string;
+			committed_points: number;
+			velocity_points: number;
+			completion_rate: number;
+		}>;
+		average_velocity: number;
+		total_sprints: number;
+	}>>;
+}
+
+export function createSprintsMethods(proxy: ProxyFn): SprintsMethods {
+	return {
+		async createSprint(projectId, params) {
+			return proxy('create_sprint', {
+				project_id: projectId,
+				...params
+			});
+		},
+
+		async updateSprint(sprintId, updates) {
+			return proxy('update_sprint', {
+				sprint_id: sprintId,
+				...updates
+			});
+		},
+
+		async getSprint(sprintId, summaryOnly) {
+			return proxy('get_sprint', {
+				sprint_id: sprintId,
+				summary_only: summaryOnly
+			});
+		},
+
+		async getSprints(projectId, params) {
+			return proxy('get_sprints', {
+				project_id: projectId,
+				...params
+			});
+		},
+
+		async deleteSprint(sprintId) {
+			return proxy('delete_sprint', { sprint_id: sprintId });
+		},
+
+		async startSprint(sprintId) {
+			return proxy('start_sprint', { sprint_id: sprintId });
+		},
+
+		async completeSprint(sprintId, params) {
+			return proxy('complete_sprint', {
+				sprint_id: sprintId,
+				...params
+			});
+		},
+
+		async addTaskToSprint(sprintId, taskId, params) {
+			return proxy('add_task_to_sprint', {
+				sprint_id: sprintId,
+				task_id: taskId,
+				...params
+			});
+		},
+
+		async removeTaskFromSprint(sprintId, taskId) {
+			return proxy('remove_task_from_sprint', {
+				sprint_id: sprintId,
+				task_id: taskId
+			});
+		},
+
+		async getSprintBacklog(projectId, sprintId, params) {
+			return proxy('get_sprint_backlog', {
+				project_id: projectId,
+				sprint_id: sprintId,
+				...params
+			});
+		},
+
+		async getSprintVelocity(projectId, limit) {
+			return proxy('get_sprint_velocity', {
+				project_id: projectId,
+				limit
+			});
+		}
+	};
+}

package/src/api-client/subtasks.ts

@@ -0,0 +1,57 @@
+/**
+ * Subtasks API Methods
+ *
+ * Methods for subtask management:
+ * - addSubtask: Add a subtask to a parent task
+ * - getSubtasks: Get subtasks for a parent task
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface SubtasksMethods {
+	addSubtask(parentTaskId: string, params: {
+		title: string;
+		description?: string;
+		priority?: number;
+		estimated_minutes?: number;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		subtask_id: string;
+		parent_task_id: string;
+	}>>;
+
+	getSubtasks(parentTaskId: string, status?: string): Promise<ApiResponse<{
+		subtasks: Array<{
+			id: string;
+			title: string;
+			description?: string;
+			priority: number;
+			status: string;
+			progress_percentage?: number;
+			estimated_minutes?: number;
+		}>;
+		stats: {
+			total: number;
+			completed: number;
+			progress_percentage: number;
+		};
+	}>>;
+}
+
+export function createSubtasksMethods(proxy: ProxyFn): SubtasksMethods {
+	return {
+		async addSubtask(parentTaskId, params, sessionId) {
+			return proxy('add_subtask', {
+				parent_task_id: parentTaskId,
+				...params
+			}, sessionId ? { session_id: sessionId } : undefined);
+		},
+
+		async getSubtasks(parentTaskId, status) {
+			return proxy('get_subtasks', {
+				parent_task_id: parentTaskId,
+				status
+			});
+		}
+	};
+}

package/src/api-client.test.ts

@@ -258,17 +258,16 @@ describe('VibescopeApiClient', () => {
 				model: 'opus',
 			});
 
-			expect(mockFetch).toHaveBeenCalledWith(
-				expect.stringContaining('/api/mcp/sessions/start'),
-				expect.objectContaining({
-					method: 'POST',
-					body: JSON.stringify({
-						project_id: 'proj-123',
-						mode: 'lite',
-						model: 'opus',
-					}),
-				})
-			);
+			const [url, opts] = mockFetch.mock.calls[0] as [string, RequestInit];
+			const body = JSON.parse(opts.body as string);
+			expect(url).toContain('/api/mcp/sessions/start');
+			expect(opts.method).toBe('POST');
+			expect(body).toMatchObject({
+				project_id: 'proj-123',
+				mode: 'lite',
+				model: 'opus',
+			});
+			expect(body.instance_id).toBeDefined();
 		});
 
 		it('should support git_url param', async () => {
@@ -280,14 +279,12 @@ describe('VibescopeApiClient', () => {
 				git_url: 'https://github.com/org/repo',
 			});
 
-			expect(mockFetch).toHaveBeenCalledWith(
-				expect.any(String),
-				expect.objectContaining({
-					body: JSON.stringify({
-						git_url: 'https://github.com/org/repo',
-					}),
-				})
-			);
+			const [, opts] = mockFetch.mock.calls[0] as [string, RequestInit];
+			const body = JSON.parse(opts.body as string);
+			expect(body).toMatchObject({
+				git_url: 'https://github.com/org/repo',
+			});
+			expect(body.instance_id).toBeDefined();
 		});
 	});
 

package/src/api-client.ts

@@ -2203,6 +2203,16 @@ export class VibescopeApiClient {
 		return this.proxy('complete_deployment_requirement', { requirement_id: requirementId });
 	}
 
+	async reorderDeploymentRequirements(projectId: string, params: {
+		stage: string;
+		requirement_ids: string[];
+	}): Promise<ApiResponse<{ success: boolean; reordered: number }>> {
+		return this.proxy('reorder_deployment_requirements', {
+			project_id: projectId,
+			...params,
+		});
+	}
+
 	async scheduleDeployment(projectId: string, params: {
 		scheduled_at: string;
 		schedule_type?: string;
@@ -2650,6 +2660,30 @@ export class VibescopeApiClient {
 			agent_type: agentType
 		});
 	}
+
+	async sendProjectMessage(projectId: string, message: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		message_id: string;
+		sent_at: string;
+	}>> {
+		return this.proxy('send_project_message', { project_id: projectId, message }, sessionId ? { session_id: sessionId, persona: null, instance_id: '' } : undefined);
+	}
+
+	async getProjectMessages(projectId: string, limit?: number): Promise<ApiResponse<{
+		messages: Array<{
+			id: string;
+			sender_type: string;
+			sender_name: string | null;
+			content: string;
+			created_at: string;
+		}>;
+		count: number;
+	}>> {
+		return this.proxy('get_project_messages', {
+			project_id: projectId,
+			...(limit !== undefined && { limit }),
+		});
+	}
 }
 
 // Singleton instance

package/src/handlers/__test-setup__.ts

@@ -190,6 +190,10 @@ export const mockApiClient = {
 	testConnector: vi.fn(),
 	getConnectorEvents: vi.fn(),
 
+	// Chat
+	sendProjectMessage: vi.fn(),
+	getProjectMessages: vi.fn(),
+
 	// Proxy (generic)
 	proxy: vi.fn(),
 };

package/src/handlers/blockers.ts

@@ -17,6 +17,7 @@ import {
 	VALID_BLOCKER_STATUSES,
 } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+import { autoPostActivity } from './chat.js';
 
 // Argument schemas for type-safe parsing
 const addBlockerSchema = {
@@ -59,6 +60,14 @@ export const addBlocker: Handler = async (args, ctx) => {
 		return error(response.error || 'Failed to add blocker');
 	}
 
+	// Auto-post blocker activity to project chat
+	const persona = ctx.session.currentPersona || 'Agent';
+	void autoPostActivity(
+		project_id,
+		`🚧 **${persona}** reported a blocker: ${description}`,
+		ctx.session.currentSessionId
+	);
+
 	return success(response.data);
 };