@vibescope/mcp-server 0.2.0 → 0.2.2

package/src/api-client.ts

@@ -47,7 +47,8 @@ export class VibescopeApiClient {
 				return {
 					ok: false,
 					status: response.status,
-					error: data.error || `HTTP ${response.status}`
+					error: data.error || `HTTP ${response.status}`,
+					data // Include full response data for additional error context
 				};
 			}
 
@@ -122,6 +123,23 @@ export class VibescopeApiClient {
 			priority: number;
 			estimated_minutes?: number;
 		} | null;
+		pending_requests?: Array<{
+			id: string;
+			request_type: string;
+			message: string;
+			created_at: string;
+		}>;
+		pending_requests_count?: number;
+		URGENT_QUESTIONS?: {
+			count: number;
+			oldest_waiting_minutes: number;
+			action_required: string;
+			requests: Array<{
+				id: string;
+				message: string;
+				waiting_minutes: number;
+			}>;
+		};
 		directive?: string;
 		blockers_count?: number;
 		validation_count?: number;
@@ -306,6 +324,7 @@ export class VibescopeApiClient {
 		estimated_minutes?: number;
 		blocking?: boolean;
 		session_id?: string;
+		task_type?: string;
 	}): Promise<ApiResponse<{
 		success: boolean;
 		task_id: string;
@@ -380,6 +399,7 @@ export class VibescopeApiClient {
 		progress_note?: string;
 		estimated_minutes?: number;
 		git_branch?: string;
+		worktree_path?: string;
 		session_id?: string;
 	}): Promise<ApiResponse<{
 		success: boolean;
@@ -539,7 +559,11 @@ export class VibescopeApiClient {
 	// ============================================================================
 	// Decision endpoints
 	// ============================================================================
-	async getDecisions(projectId: string): Promise<ApiResponse<{
+	async getDecisions(projectId: string, options?: {
+		limit?: number;
+		offset?: number;
+		search_query?: string;
+	}): Promise<ApiResponse<{
 		decisions: Array<{
 			id: string;
 			title: string;
@@ -549,7 +573,7 @@ export class VibescopeApiClient {
 			created_at: string;
 		}>;
 	}>> {
-		return this.proxy('get_decisions', { project_id: projectId });
+		return this.proxy('get_decisions', { project_id: projectId, ...options });
 	}
 
 	async logDecision(projectId: string, params: {
@@ -1005,6 +1029,8 @@ export class VibescopeApiClient {
 	async getActivityFeed(projectId: string, params?: {
 		limit?: number;
 		since?: string;
+		types?: string[];
+		created_by?: string;
 	}): Promise<ApiResponse<{
 		activities: Array<{
 			type: string;
@@ -1139,14 +1165,17 @@ export class VibescopeApiClient {
 	// Knowledge base endpoint
 	// ============================================================================
 	async queryKnowledgeBase(projectId: string, params?: {
+		scope?: 'summary' | 'detailed';
 		categories?: string[];
 		limit?: number;
 		search_query?: string;
 	}): Promise<ApiResponse<{
-		findings?: Array<{ id: string; title: string; category: string; severity: string }>;
-		decisions?: Array<{ id: string; title: string; description: string }>;
-		completed_tasks?: Array<{ id: string; title: string; completed_at: string }>;
+		findings?: Array<{ id: string; title: string; category: string; severity: string; description?: string }>;
+		decisions?: Array<{ id: string; title: string; description: string; rationale?: string }>;
+		completed_tasks?: Array<{ id: string; title: string; completed_at: string; summary?: string }>;
 		resolved_blockers?: Array<{ id: string; description: string; resolution_note?: string }>;
+		progress?: Array<{ id: string; summary: string; details?: string }>;
+		qa?: Array<{ id: string; question: string; answer: string }>;
 	}>> {
 		return this.proxy('query_knowledge_base', {
 			project_id: projectId,
@@ -1598,6 +1627,63 @@ export class VibescopeApiClient {
 		});
 	}
 
+	async getBodyOfWorkCosts(params: {
+		body_of_work_id?: string;
+		project_id?: string;
+	}): Promise<ApiResponse<{
+		bodies_of_work: Array<{
+			body_of_work_id: string;
+			title: string;
+			project_id: string;
+			status: string;
+			task_count: number;
+			total_cost_usd: number;
+			total_tokens: number;
+			pre_phase_cost_usd: number;
+			core_phase_cost_usd: number;
+			post_phase_cost_usd: number;
+			model_breakdown: Record<string, { input: number; output: number }>;
+		}>;
+		count: number;
+		totals: {
+			total_cost_usd: number;
+			total_tokens: number;
+			total_tasks: number;
+		};
+	}>> {
+		return this.proxy('get_body_of_work_costs', params);
+	}
+
+	async getSprintCosts(params: {
+		sprint_id?: string;
+		project_id?: string;
+	}): Promise<ApiResponse<{
+		sprints: Array<{
+			sprint_id: string;
+			title: string;
+			project_id: string;
+			status: string;
+			sprint_number: number;
+			task_count: number;
+			total_cost_usd: number;
+			total_tokens: number;
+			cost_per_story_point: number | null;
+			committed_points: number;
+			velocity_points: number;
+			model_breakdown: Record<string, { input: number; output: number }>;
+		}>;
+		count: number;
+		totals: {
+			total_cost_usd: number;
+			total_tokens: number;
+			total_tasks: number;
+			total_velocity_points: number;
+			avg_cost_per_point: number | null;
+		};
+	}>> {
+		return this.proxy('get_sprint_costs', params);
+	}
+
 	async getTokenUsage(): Promise<ApiResponse<{
 		session_tokens: number;
 		estimated_cost: number;
@@ -1684,6 +1770,7 @@ export class VibescopeApiClient {
 		environment?: string;
 		version_bump?: string;
 		auto_trigger?: boolean;
+		hours_interval?: number;
 		notes?: string;
 		git_ref?: string;
 	}): Promise<ApiResponse<{
@@ -1701,6 +1788,7 @@ export class VibescopeApiClient {
 			id: string;
 			scheduled_at: string;
 			schedule_type: string;
+			hours_interval: number;
 			environment: string;
 			version_bump: string;
 			auto_trigger: boolean;
@@ -1720,6 +1808,7 @@ export class VibescopeApiClient {
 	async updateScheduledDeployment(scheduleId: string, updates: {
 		scheduled_at?: string;
 		schedule_type?: string;
+		hours_interval?: number;
 		environment?: string;
 		version_bump?: string;
 		auto_trigger?: boolean;
@@ -1800,6 +1889,231 @@ export class VibescopeApiClient {
 	}>>> {
 		return this.proxy('get_help_topics', {});
 	}
+
+	// ============================================================================
+	// File Checkout endpoints (multi-agent coordination)
+	// ============================================================================
+	async checkoutFile(projectId: string, filePath: string, reason?: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		file_path: string;
+		already_checked_out?: boolean;
+		message: string;
+	}>> {
+		return this.proxy('checkout_file', {
+			project_id: projectId,
+			file_path: filePath,
+			reason
+		}, sessionId ? {
+			session_id: sessionId,
+			persona: null,
+			instance_id: ''
+		} : undefined);
+	}
+
+	async checkinFile(params: {
+		checkout_id?: string;
+		project_id?: string;
+		file_path?: string;
+		summary?: string;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		message: string;
+	}>> {
+		return this.proxy('checkin_file', params, sessionId ? {
+			session_id: sessionId,
+			persona: null,
+			instance_id: ''
+		} : undefined);
+	}
+
+	async getFileCheckouts(projectId: string, options?: {
+		status?: string;
+		file_path?: string;
+		limit?: number;
+	}): Promise<ApiResponse<{
+		checkouts: Array<{
+			id: string;
+			file_path: string;
+			status: string;
+			checked_out_at: string;
+			checkout_reason?: string;
+			checked_in_at?: string;
+			checkin_summary?: string;
+			checked_out_by?: string;
+		}>;
+	}>> {
+		return this.proxy('get_file_checkouts', {
+			project_id: projectId,
+			...options
+		});
+	}
+
+	async abandonCheckout(params: {
+		checkout_id?: string;
+		project_id?: string;
+		file_path?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		checkout_id: string;
+		message: string;
+	}>> {
+		return this.proxy('abandon_checkout', params);
+	}
+
+	// ============================================================================
+	// Worktree Management
+	// ============================================================================
+
+	async getStaleWorktrees(projectId: string): Promise<ApiResponse<{
+		project_id: string;
+		project_name: string;
+		stale_worktrees: Array<{
+			task_id: string;
+			task_title: string;
+			worktree_path: string;
+			git_branch: string | null;
+			status: string;
+			completed_at: string | null;
+			updated_at: string;
+			pr_url: string | null;
+			stale_reason: 'task_finished' | 'potentially_abandoned';
+		}>;
+		count: number;
+		cleanup_instructions: string[] | null;
+	}>> {
+		return this.request('GET', `/api/mcp/worktrees/stale?project_id=${projectId}`);
+	}
+
+	async clearWorktreePath(taskId: string): Promise<ApiResponse<{
+		success: boolean;
+		task_id: string;
+	}>> {
+		return this.request('PATCH', `/api/mcp/tasks/${taskId}`, { worktree_path: null });
+	}
+
+	// ============================================================================
+	// Connector endpoints
+	// ============================================================================
+
+	async getConnectors(projectId: string, params?: {
+		type?: string;
+		status?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		connectors: Array<{
+			id: string;
+			name: string;
+			type: string;
+			description?: string;
+			status: string;
+			events: Record<string, boolean>;
+			events_sent: number;
+			last_triggered_at?: string;
+			last_error?: string;
+			last_error_at?: string;
+			created_at: string;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>> {
+		return this.proxy('get_connectors', {
+			project_id: projectId,
+			...params
+		});
+	}
+
+	async getConnector(connectorId: string): Promise<ApiResponse<{
+		connector: {
+			id: string;
+			name: string;
+			type: string;
+			description?: string;
+			config: Record<string, unknown>;
+			events: Record<string, boolean>;
+			status: string;
+			events_sent: number;
+			last_triggered_at?: string;
+			last_error?: string;
+			last_error_at?: string;
+			created_at: string;
+		};
+	}>> {
+		return this.proxy('get_connector', { connector_id: connectorId });
+	}
+
+	async addConnector(projectId: string, params: {
+		name: string;
+		type: string;
+		description?: string;
+		config?: Record<string, unknown>;
+		events?: Record<string, boolean>;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		connector_id: string;
+	}>> {
+		return this.proxy('add_connector', {
+			project_id: projectId,
+			...params
+		});
+	}
+
+	async updateConnector(connectorId: string, updates: {
+		name?: string;
+		description?: string;
+		config?: Record<string, unknown>;
+		events?: Record<string, boolean>;
+		status?: string;
+	}): Promise<ApiResponse<{
+		success: boolean;
+		connector_id: string;
+	}>> {
+		return this.proxy('update_connector', {
+			connector_id: connectorId,
+			...updates
+		});
+	}
+
+	async deleteConnector(connectorId: string): Promise<ApiResponse<{
+		success: boolean;
+	}>> {
+		return this.proxy('delete_connector', { connector_id: connectorId });
+	}
+
+	async testConnector(connectorId: string): Promise<ApiResponse<{
+		success: boolean;
+		event_id: string;
+		status?: number;
+		error?: string;
+	}>> {
+		return this.proxy('test_connector', { connector_id: connectorId });
+	}
+
+	async getConnectorEvents(params: {
+		connector_id?: string;
+		project_id?: string;
+		status?: string;
+		limit?: number;
+		offset?: number;
+	}): Promise<ApiResponse<{
+		events: Array<{
+			id: string;
+			connector_id: string;
+			event_type: string;
+			status: string;
+			response_status?: number;
+			error_message?: string;
+			attempts: number;
+			created_at: string;
+			sent_at?: string;
+		}>;
+		total_count: number;
+		has_more: boolean;
+	}>> {
+		return this.proxy('get_connector_events', params);
+	}
 }
 
 // Singleton instance

package/src/handlers/__test-setup__.ts

@@ -80,6 +80,7 @@ export const mockApiClient = {
 	getFindingsStats: vi.fn(),
 	updateFinding: vi.fn(),
 	deleteFinding: vi.fn(),
+	queryKnowledgeBase: vi.fn(),
 
 	// Requests
 	getPendingRequests: vi.fn(),
@@ -169,6 +170,21 @@ export const mockApiClient = {
 	getHelpTopic: vi.fn(),
 	getHelpTopics: vi.fn(),
 
+	// File Checkouts
+	checkoutFile: vi.fn(),
+	checkinFile: vi.fn(),
+	getFileCheckouts: vi.fn(),
+	abandonCheckout: vi.fn(),
+
+	// Connectors
+	getConnectors: vi.fn(),
+	getConnector: vi.fn(),
+	addConnector: vi.fn(),
+	updateConnector: vi.fn(),
+	deleteConnector: vi.fn(),
+	testConnector: vi.fn(),
+	getConnectorEvents: vi.fn(),
+
 	// Proxy (generic)
 	proxy: vi.fn(),
 };

package/src/handlers/blockers.test.ts

@@ -83,19 +83,22 @@ describe('addBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.addBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			addBlocker({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				description: 'Test blocker',
-			}, ctx)
-		).rejects.toThrow('Insert failed');
+		const result = await addBlocker({
+			project_id: '123e4567-e89b-12d3-a456-426614174000',
+			description: 'Test blocker',
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
 	});
 });
 
@@ -177,16 +180,19 @@ describe('resolveBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.resolveBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Update failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Update failed');
+		const result = await resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Update failed',
+		});
 	});
 });
 
@@ -298,16 +304,19 @@ describe('getBlockers', () => {
 		expect(mockApiClient.getBlockers).toHaveBeenCalled();
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.getBlockers.mockResolvedValue({
 			ok: false,
 			error: 'Query failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Query failed');
+		const result = await getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Query failed',
+		});
 	});
 });
 
@@ -366,15 +375,18 @@ describe('deleteBlocker', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.deleteBlocker.mockResolvedValue({
 			ok: false,
 			error: 'Delete failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Delete failed');
+		const result = await deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Delete failed',
+		});
 	});
 });

package/src/handlers/blockers.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
+import { success, error } from './types.js';
 import {
 	parseArgs,
 	uuidValidator,
@@ -47,10 +48,10 @@ export const addBlocker: Handler = async (args, ctx) => {
 	const response = await apiClient.addBlocker(project_id, description, ctx.session.currentSessionId || undefined);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to add blocker');
+		return error(response.error || 'Failed to add blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const resolveBlocker: Handler = async (args, _ctx) => {
@@ -60,10 +61,10 @@ export const resolveBlocker: Handler = async (args, _ctx) => {
 	const response = await apiClient.resolveBlocker(blocker_id, resolution_note);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to resolve blocker');
+		return error(response.error || 'Failed to resolve blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const getBlockers: Handler = async (args, _ctx) => {
@@ -78,10 +79,10 @@ export const getBlockers: Handler = async (args, _ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to fetch blockers');
+		return error(response.error || 'Failed to fetch blockers');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 export const deleteBlocker: Handler = async (args, _ctx) => {
@@ -91,10 +92,10 @@ export const deleteBlocker: Handler = async (args, _ctx) => {
 	const response = await apiClient.deleteBlocker(blocker_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to delete blocker');
+		return error(response.error || 'Failed to delete blocker');
 	}
 
-	return { result: response.data };
+	return success(response.data);
 };
 
 /**