@vibescope/mcp-server 0.2.0 → 0.2.2

package/src/handlers/connectors.ts

@@ -0,0 +1,229 @@
+/**
+ * Connectors Handlers
+ *
+ * Handles external integration management:
+ * - get_connectors
+ * - get_connector
+ * - add_connector
+ * - update_connector
+ * - delete_connector
+ * - test_connector
+ * - get_connector_events
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { success, error } from './types.js';
+import {
+	parseArgs,
+	uuidValidator,
+	createEnumValidator,
+} from '../validators.js';
+import { getApiClient } from '../api-client.js';
+
+// Valid connector types
+const VALID_CONNECTOR_TYPES = ['webhook', 'slack', 'discord', 'github', 'custom'] as const;
+
+// Valid connector statuses
+const VALID_CONNECTOR_STATUSES = ['active', 'disabled'] as const;
+
+// Valid event statuses
+const VALID_EVENT_STATUSES = ['pending', 'sent', 'failed', 'retrying'] as const;
+
+// Argument schemas for type-safe parsing
+const getConnectorsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	type: { type: 'string' as const, validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+	status: { type: 'string' as const, validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+};
+
+const getConnectorSchema = {
+	connector_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const addConnectorSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	name: { type: 'string' as const, required: true as const },
+	type: { type: 'string' as const, required: true as const, validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+	description: { type: 'string' as const },
+	config: { type: 'object' as const },
+	events: { type: 'object' as const },
+};
+
+const updateConnectorSchema = {
+	connector_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	name: { type: 'string' as const },
+	description: { type: 'string' as const },
+	config: { type: 'object' as const },
+	events: { type: 'object' as const },
+	status: { type: 'string' as const, validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+};
+
+const deleteConnectorSchema = {
+	connector_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const testConnectorSchema = {
+	connector_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getConnectorEventsSchema = {
+	connector_id: { type: 'string' as const, validate: uuidValidator },
+	project_id: { type: 'string' as const, validate: uuidValidator },
+	status: { type: 'string' as const, validate: createEnumValidator(VALID_EVENT_STATUSES) },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+};
+
+/**
+ * Get all connectors for a project
+ */
+export const getConnectors: Handler = async (args, _ctx) => {
+	const { project_id, type, status, limit, offset } = parseArgs(args, getConnectorsSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getConnectors(project_id, {
+		type,
+		status,
+		limit,
+		offset
+	});
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to fetch connectors');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Get a single connector with full details
+ */
+export const getConnector: Handler = async (args, _ctx) => {
+	const { connector_id } = parseArgs(args, getConnectorSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getConnector(connector_id);
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to fetch connector');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Add a new connector
+ */
+export const addConnector: Handler = async (args, _ctx) => {
+	const { project_id, name, type, description, config, events } = parseArgs(args, addConnectorSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.addConnector(project_id, {
+		name,
+		type,
+		description,
+		config: config as Record<string, unknown> | undefined,
+		events: events as Record<string, boolean> | undefined
+	});
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to create connector');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Update a connector
+ */
+export const updateConnector: Handler = async (args, _ctx) => {
+	const { connector_id, name, description, config, events, status } = parseArgs(args, updateConnectorSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.updateConnector(connector_id, {
+		name,
+		description,
+		config: config as Record<string, unknown> | undefined,
+		events: events as Record<string, boolean> | undefined,
+		status
+	});
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to update connector');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Delete a connector
+ */
+export const deleteConnector: Handler = async (args, _ctx) => {
+	const { connector_id } = parseArgs(args, deleteConnectorSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.deleteConnector(connector_id);
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to delete connector');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Test a connector by sending a test event
+ */
+export const testConnector: Handler = async (args, _ctx) => {
+	const { connector_id } = parseArgs(args, testConnectorSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.testConnector(connector_id);
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to test connector');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Get connector event history
+ */
+export const getConnectorEvents: Handler = async (args, _ctx) => {
+	const { connector_id, project_id, status, limit, offset } = parseArgs(args, getConnectorEventsSchema);
+
+	if (!connector_id && !project_id) {
+		return error('Either connector_id or project_id is required');
+	}
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getConnectorEvents({
+		connector_id,
+		project_id,
+		status,
+		limit,
+		offset
+	});
+
+	if (!response.ok) {
+		return error(response.error || 'Failed to fetch connector events');
+	}
+
+	return success(response.data);
+};
+
+/**
+ * Connectors handlers registry
+ */
+export const connectorHandlers: HandlerRegistry = {
+	get_connectors: getConnectors,
+	get_connector: getConnector,
+	add_connector: addConnector,
+	update_connector: updateConnector,
+	delete_connector: deleteConnector,
+	test_connector: testConnector,
+	get_connector_events: getConnectorEvents,
+};

package/src/handlers/cost.test.ts

@@ -13,6 +13,7 @@ import {
 } from './cost.js';
 import { createMockContext } from './__test-utils__.js';
 import { mockApiClient } from './__test-setup__.js';
+import { ValidationError } from '../validators.js';
 
 const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
 
@@ -26,13 +27,11 @@ describe('Cost Handlers', () => {
 	// ============================================================================
 
 	describe('getCostSummary', () => {
-		it('should return error when project_id is missing', async () => {
+		it('should throw ValidationError when project_id is missing', async () => {
 			const ctx = createMockContext();
 
-			const result = await getCostSummary({}, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result).toEqual({ error: 'project_id is required' });
+			await expect(getCostSummary({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(getCostSummary({}, ctx)).rejects.toThrow('Missing required field: project_id');
 		});
 
 		it('should return daily cost summary with totals', async () => {
@@ -185,40 +184,37 @@ describe('Cost Handlers', () => {
 	// ============================================================================
 
 	describe('addCostAlert', () => {
-		it('should return error when threshold_amount is missing', async () => {
+		it('should throw ValidationError when threshold_amount is missing', async () => {
 			const ctx = createMockContext();
 
-			const result = await addCostAlert(
-				{ threshold_period: 'daily' },
-				ctx
-			);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('threshold_amount must be a positive number');
+			await expect(
+				addCostAlert({ threshold_period: 'daily' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_period: 'daily' }, ctx)
+			).rejects.toThrow('Missing required field: threshold_amount');
 		});
 
-		it('should return error when threshold_amount is not positive', async () => {
+		it('should throw ValidationError when threshold_amount is not positive', async () => {
 			const ctx = createMockContext();
 
-			const result = await addCostAlert(
-				{ threshold_amount: -5, threshold_period: 'daily' },
-				ctx
-			);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('threshold_amount must be a positive number');
+			await expect(
+				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_amount: -5, threshold_period: 'daily' }, ctx)
+			).rejects.toThrow('threshold_amount must be a positive number');
 		});
 
-		it('should return error when threshold_period is invalid', async () => {
+		it('should throw ValidationError when threshold_period is invalid', async () => {
 			const ctx = createMockContext();
 
-			const result = await addCostAlert(
-				{ threshold_amount: 10, threshold_period: 'yearly' },
-				ctx
-			);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toContain('threshold_period must be');
+			await expect(
+				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
+			).rejects.toThrow(ValidationError);
+			await expect(
+				addCostAlert({ threshold_amount: 10, threshold_period: 'yearly' }, ctx)
+			).rejects.toThrow('Invalid threshold_period');
 		});
 
 		it('should create alert successfully', async () => {
@@ -291,13 +287,11 @@ describe('Cost Handlers', () => {
 	// ============================================================================
 
 	describe('updateCostAlert', () => {
-		it('should return error when alert_id is missing', async () => {
+		it('should throw ValidationError when alert_id is missing', async () => {
 			const ctx = createMockContext();
 
-			const result = await updateCostAlert({}, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('alert_id is required');
+			await expect(updateCostAlert({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(updateCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
 		});
 
 		it('should return error when no updates provided', async () => {
@@ -367,13 +361,11 @@ describe('Cost Handlers', () => {
 	// ============================================================================
 
 	describe('deleteCostAlert', () => {
-		it('should return error when alert_id is missing', async () => {
+		it('should throw ValidationError when alert_id is missing', async () => {
 			const ctx = createMockContext();
 
-			const result = await deleteCostAlert({}, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('alert_id is required');
+			await expect(deleteCostAlert({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(deleteCostAlert({}, ctx)).rejects.toThrow('Missing required field: alert_id');
 		});
 
 		it('should delete alert successfully', async () => {
@@ -408,13 +400,11 @@ describe('Cost Handlers', () => {
 	// ============================================================================
 
 	describe('getTaskCosts', () => {
-		it('should return error when project_id is missing', async () => {
+		it('should throw ValidationError when project_id is missing', async () => {
 			const ctx = createMockContext();
 
-			const result = await getTaskCosts({}, ctx);
-
-			expect(result.isError).toBe(true);
-			expect(result.result.error).toBe('project_id is required');
+			await expect(getTaskCosts({}, ctx)).rejects.toThrow(ValidationError);
+			await expect(getTaskCosts({}, ctx)).rejects.toThrow('Missing required field: project_id');
 		});
 
 		it('should return task costs with total', async () => {

package/src/handlers/cost.ts

@@ -8,30 +8,83 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
+const VALID_PERIODS = ['daily', 'weekly', 'monthly'] as const;
+const VALID_ALERT_TYPES = ['warning', 'critical'] as const;
+
+type Period = typeof VALID_PERIODS[number];
+type AlertType = typeof VALID_ALERT_TYPES[number];
+
+// Argument schemas for type-safe parsing
+const getCostSummarySchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	period: { type: 'string' as const, default: 'daily', validate: createEnumValidator(VALID_PERIODS) },
+	limit: { type: 'number' as const, default: 30 },
+};
+
+const getCostAlertsSchema = {
+	project_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+const addCostAlertSchema = {
+	project_id: { type: 'string' as const, validate: uuidValidator },
+	threshold_amount: { type: 'number' as const, required: true as const },
+	threshold_period: { type: 'string' as const, required: true as const, validate: createEnumValidator(VALID_PERIODS) },
+	alert_type: { type: 'string' as const, default: 'warning', validate: createEnumValidator(VALID_ALERT_TYPES) },
+};
+
+const updateCostAlertSchema = {
+	alert_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	threshold_amount: { type: 'number' as const },
+	threshold_period: { type: 'string' as const, validate: createEnumValidator(VALID_PERIODS) },
+	alert_type: { type: 'string' as const, validate: createEnumValidator(VALID_ALERT_TYPES) },
+	enabled: { type: 'boolean' as const },
+};
+
+const deleteCostAlertSchema = {
+	alert_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getTaskCostsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	limit: { type: 'number' as const, default: 20 },
+};
+
+const getBodyOfWorkCostsSchema = {
+	body_of_work_id: { type: 'string' as const, validate: uuidValidator },
+	project_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+const getSprintCostsSchema = {
+	sprint_id: { type: 'string' as const, validate: uuidValidator },
+	project_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+// Custom validator for positive numbers
+function validatePositiveNumber(value: number | undefined, fieldName: string): void {
+	if (value !== undefined && value <= 0) {
+		throw new ValidationError(`${fieldName} must be a positive number`, { field: fieldName });
+	}
+}
+
 /**
  * Get cost summary for a project (daily, weekly, or monthly)
  */
-export const getCostSummary: Handler = async (args, ctx) => {
-	const { project_id, period = 'daily', limit = 30 } = args as {
-		project_id: string;
-		period?: 'daily' | 'weekly' | 'monthly';
-		limit?: number;
-	};
-
-	if (!project_id) {
-		return {
-			result: { error: 'project_id is required' },
-			isError: true,
-		};
-	}
+export const getCostSummary: Handler = async (args, _ctx) => {
+	const { project_id, period, limit } = parseArgs(args, getCostSummarySchema);
 
 	const apiClient = getApiClient();
-	const response = await apiClient.getCostSummary(project_id, { period, limit });
+	const response = await apiClient.getCostSummary(project_id, {
+		period: period as Period,
+		limit
+	});
 
 	if (!response.ok) {
 		return {
@@ -46,8 +99,8 @@ export const getCostSummary: Handler = async (args, ctx) => {
 /**
  * Get cost alerts for the current user
  */
-export const getCostAlerts: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id?: string };
+export const getCostAlerts: Handler = async (args, _ctx) => {
+	const { project_id } = parseArgs(args, getCostAlertsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getCostAlerts();
@@ -65,39 +118,18 @@ export const getCostAlerts: Handler = async (args, ctx) => {
 /**
  * Add a cost alert
  */
-export const addCostAlert: Handler = async (args, ctx) => {
-	const {
-		project_id,
-		threshold_amount,
-		threshold_period,
-		alert_type = 'warning',
-	} = args as {
-		project_id?: string;
-		threshold_amount: number;
-		threshold_period: 'daily' | 'weekly' | 'monthly';
-		alert_type?: 'warning' | 'critical';
-	};
-
-	if (!threshold_amount || threshold_amount <= 0) {
-		return {
-			result: { error: 'threshold_amount must be a positive number' },
-			isError: true,
-		};
-	}
+export const addCostAlert: Handler = async (args, _ctx) => {
+	const { project_id, threshold_amount, threshold_period, alert_type } = parseArgs(args, addCostAlertSchema);
 
-	if (!threshold_period || !['daily', 'weekly', 'monthly'].includes(threshold_period)) {
-		return {
-			result: { error: 'threshold_period must be "daily", "weekly", or "monthly"' },
-			isError: true,
-		};
-	}
+	// Additional validation for positive amount
+	validatePositiveNumber(threshold_amount, 'threshold_amount');
 
 	const apiClient = getApiClient();
 	const response = await apiClient.addCostAlert({
 		project_id,
-		threshold_amount,
-		threshold_period,
-		alert_type
+		threshold_amount: threshold_amount!,
+		threshold_period: threshold_period as Period,
+		alert_type: alert_type as AlertType
 	});
 
 	if (!response.ok) {
@@ -113,52 +145,53 @@ export const addCostAlert: Handler = async (args, ctx) => {
 /**
  * Update a cost alert
  */
-export const updateCostAlert: Handler = async (args, ctx) => {
-	const {
-		alert_id,
-		threshold_amount,
-		threshold_period,
-		alert_type,
-		enabled,
-	} = args as {
-		alert_id: string;
-		threshold_amount?: number;
-		threshold_period?: 'daily' | 'weekly' | 'monthly';
-		alert_type?: 'warning' | 'critical';
-		enabled?: boolean;
-	};
+export const updateCostAlert: Handler = async (args, _ctx) => {
+	const { alert_id, threshold_amount, threshold_period, alert_type, enabled } = parseArgs(args, updateCostAlertSchema);
 
-	if (!alert_id) {
+	// Check that at least one update is provided
+	if (threshold_amount === undefined && threshold_period === undefined && alert_type === undefined && enabled === undefined) {
 		return {
-			result: { error: 'alert_id is required' },
+			result: { error: 'No updates provided' },
 			isError: true,
 		};
 	}
 
 	const updates: {
 		threshold_amount?: number;
-		threshold_period?: 'daily' | 'weekly' | 'monthly';
-		alert_type?: 'warning' | 'critical';
+		threshold_period?: Period;
+		alert_type?: AlertType;
 		enabled?: boolean;
 	} = {};
 	if (threshold_amount !== undefined) updates.threshold_amount = threshold_amount;
-	if (threshold_period !== undefined) updates.threshold_period = threshold_period;
-	if (alert_type !== undefined) updates.alert_type = alert_type;
+	if (threshold_period !== undefined) updates.threshold_period = threshold_period as Period;
+	if (alert_type !== undefined) updates.alert_type = alert_type as AlertType;
 	if (enabled !== undefined) updates.enabled = enabled;
 
-	if (Object.keys(updates).length === 0) {
+	const apiClient = getApiClient();
+	const response = await apiClient.updateCostAlert(alert_id, updates);
+
+	if (!response.ok) {
 		return {
-			result: { error: 'No updates provided' },
+			result: { error: response.error || 'Failed to update cost alert' },
 			isError: true,
 		};
 	}
 
+	return { result: response.data };
+};
+
+/**
+ * Delete a cost alert
+ */
+export const deleteCostAlert: Handler = async (args, _ctx) => {
+	const { alert_id } = parseArgs(args, deleteCostAlertSchema);
+
 	const apiClient = getApiClient();
-	const response = await apiClient.updateCostAlert(alert_id, updates);
+	const response = await apiClient.deleteCostAlert(alert_id);
 
 	if (!response.ok) {
 		return {
-			result: { error: response.error || 'Failed to update cost alert' },
+			result: { error: response.error || 'Failed to delete cost alert' },
 			isError: true,
 		};
 	}
@@ -167,24 +200,43 @@ export const updateCostAlert: Handler = async (args, ctx) => {
 };
 
 /**
- * Delete a cost alert
+ * Get task costs for a project
+ */
+export const getTaskCosts: Handler = async (args, _ctx) => {
+	const { project_id, limit } = parseArgs(args, getTaskCostsSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getTaskCosts(project_id, limit);
+
+	if (!response.ok) {
+		return {
+			result: { error: response.error || 'Failed to get task costs' },
+			isError: true,
+		};
+	}
+
+	return { result: response.data };
+};
+
+/**
+ * Get body of work costs with phase breakdown
  */
-export const deleteCostAlert: Handler = async (args, ctx) => {
-	const { alert_id } = args as { alert_id: string };
+export const getBodyOfWorkCosts: Handler = async (args, _ctx) => {
+	const { body_of_work_id, project_id } = parseArgs(args, getBodyOfWorkCostsSchema);
 
-	if (!alert_id) {
+	if (!body_of_work_id && !project_id) {
 		return {
-			result: { error: 'alert_id is required' },
+			result: { error: 'Either body_of_work_id or project_id is required' },
 			isError: true,
 		};
 	}
 
 	const apiClient = getApiClient();
-	const response = await apiClient.deleteCostAlert(alert_id);
+	const response = await apiClient.getBodyOfWorkCosts({ body_of_work_id, project_id });
 
 	if (!response.ok) {
 		return {
-			result: { error: response.error || 'Failed to delete cost alert' },
+			result: { error: response.error || 'Failed to get body of work costs' },
 			isError: true,
 		};
 	}
@@ -193,27 +245,24 @@ export const deleteCostAlert: Handler = async (args, ctx) => {
 };
 
 /**
- * Get task costs for a project
+ * Get sprint costs with velocity metrics
  */
-export const getTaskCosts: Handler = async (args, ctx) => {
-	const { project_id, limit = 20 } = args as {
-		project_id: string;
-		limit?: number;
-	};
+export const getSprintCosts: Handler = async (args, _ctx) => {
+	const { sprint_id, project_id } = parseArgs(args, getSprintCostsSchema);
 
-	if (!project_id) {
+	if (!sprint_id && !project_id) {
 		return {
-			result: { error: 'project_id is required' },
+			result: { error: 'Either sprint_id or project_id is required' },
 			isError: true,
 		};
 	}
 
 	const apiClient = getApiClient();
-	const response = await apiClient.getTaskCosts(project_id, limit);
+	const response = await apiClient.getSprintCosts({ sprint_id, project_id });
 
 	if (!response.ok) {
 		return {
-			result: { error: response.error || 'Failed to get task costs' },
+			result: { error: response.error || 'Failed to get sprint costs' },
 			isError: true,
 		};
 	}
@@ -231,4 +280,6 @@ export const costHandlers: HandlerRegistry = {
 	update_cost_alert: updateCostAlert,
 	delete_cost_alert: deleteCostAlert,
 	get_task_costs: getTaskCosts,
+	get_body_of_work_costs: getBodyOfWorkCosts,
+	get_sprint_costs: getSprintCosts,
 };