@vibescope/mcp-server 0.2.1 → 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.ts

@@ -8,6 +8,8 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
@@ -55,6 +57,16 @@ const getTaskCostsSchema = {
 	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) {
@@ -206,6 +218,58 @@ export const getTaskCosts: Handler = async (args, _ctx) => {
 	return { result: response.data };
 };
 
+/**
+ * Get body of work costs with phase breakdown
+ */
+export const getBodyOfWorkCosts: Handler = async (args, _ctx) => {
+	const { body_of_work_id, project_id } = parseArgs(args, getBodyOfWorkCostsSchema);
+
+	if (!body_of_work_id && !project_id) {
+		return {
+			result: { error: 'Either body_of_work_id or project_id is required' },
+			isError: true,
+		};
+	}
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getBodyOfWorkCosts({ body_of_work_id, project_id });
+
+	if (!response.ok) {
+		return {
+			result: { error: response.error || 'Failed to get body of work costs' },
+			isError: true,
+		};
+	}
+
+	return { result: response.data };
+};
+
+/**
+ * Get sprint costs with velocity metrics
+ */
+export const getSprintCosts: Handler = async (args, _ctx) => {
+	const { sprint_id, project_id } = parseArgs(args, getSprintCostsSchema);
+
+	if (!sprint_id && !project_id) {
+		return {
+			result: { error: 'Either sprint_id or project_id is required' },
+			isError: true,
+		};
+	}
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getSprintCosts({ sprint_id, project_id });
+
+	if (!response.ok) {
+		return {
+			result: { error: response.error || 'Failed to get sprint costs' },
+			isError: true,
+		};
+	}
+
+	return { result: response.data };
+};
+
 /**
  * Cost handlers registry
  */
@@ -216,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,
 };

package/src/handlers/decisions.test.ts

@@ -119,23 +119,26 @@ describe('logDecision', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.logDecision.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			logDecision(
-				{
-					project_id: '123e4567-e89b-12d3-a456-426614174000',
-					title: 'Test',
-					description: 'Test',
-				},
-				ctx
-			)
-		).rejects.toThrow('Failed to log decision: Insert failed');
+		const result = await logDecision(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Test',
+				description: 'Test',
+			},
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
 	});
 });
 
@@ -216,19 +219,22 @@ describe('getDecisions', () => {
 		);
 	});
 
-	it('should throw error when query fails', async () => {
+	it('should return error when query fails', async () => {
 		mockApiClient.getDecisions.mockResolvedValue({
 			ok: false,
 			error: 'Query failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getDecisions(
-				{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-				ctx
-			)
-		).rejects.toThrow('Failed to fetch decisions: Query failed');
+		const result = await getDecisions(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Query failed',
+		});
 	});
 });
 
@@ -287,18 +293,21 @@ describe('deleteDecision', () => {
 		);
 	});
 
-	it('should throw error when delete fails', async () => {
+	it('should return error when delete fails', async () => {
 		mockApiClient.deleteDecision.mockResolvedValue({
 			ok: false,
 			error: 'Delete failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteDecision(
-				{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
-				ctx
-			)
-		).rejects.toThrow('Failed to delete decision: Delete failed');
+		const result = await deleteDecision(
+			{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Delete failed',
+		});
 	});
 });

package/src/handlers/decisions.ts

@@ -47,7 +47,7 @@ export const logDecision: Handler = async (args, ctx) => {
 	}, session.currentSessionId || undefined);
 
 	if (!response.ok) {
-		throw new Error(`Failed to log decision: ${response.error}`);
+		return { result: { error: response.error || 'Failed to log decision' }, isError: true };
 	}
 
 	return { result: { success: true, title, decision_id: response.data?.decision_id } };
@@ -65,7 +65,7 @@ export const getDecisions: Handler = async (args, _ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to fetch decisions: ${response.error}`);
+		return { result: { error: response.error || 'Failed to fetch decisions' }, isError: true };
 	}
 
 	return {
@@ -83,7 +83,7 @@ export const deleteDecision: Handler = async (args, _ctx) => {
 	const response = await apiClient.deleteDecision(decision_id);
 
 	if (!response.ok) {
-		throw new Error(`Failed to delete decision: ${response.error}`);
+		return { result: { error: response.error || 'Failed to delete decision' }, isError: true };
 	}
 
 	return { result: { success: true } };

package/src/handlers/deployment.ts

@@ -28,7 +28,7 @@ const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
 const REQUIREMENT_TYPES = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'] as const;
 const REQUIREMENT_STAGES = ['preparation', 'deployment', 'verification'] as const;
 const REQUIREMENT_STATUSES = ['pending', 'completed', 'converted_to_task', 'all'] as const;
-const SCHEDULE_TYPES = ['once', 'daily', 'weekly', 'monthly'] as const;
+const SCHEDULE_TYPES = ['once', 'hourly', 'daily', 'weekly', 'monthly'] as const;
 
 type Environment = typeof ENVIRONMENTS[number];
 type VersionBump = typeof VERSION_BUMPS[number];
@@ -107,6 +107,7 @@ const scheduleDeploymentSchema = {
 	schedule_type: { type: 'string' as const, default: 'once', validate: createEnumValidator(SCHEDULE_TYPES) },
 	scheduled_at: { type: 'string' as const, required: true as const },
 	auto_trigger: { type: 'boolean' as const, default: true },
+	hours_interval: { type: 'number' as const, default: 1 },
 	notes: { type: 'string' as const },
 	git_ref: { type: 'string' as const },
 };
@@ -123,6 +124,7 @@ const updateScheduledDeploymentSchema = {
 	schedule_type: { type: 'string' as const, validate: createEnumValidator(SCHEDULE_TYPES) },
 	scheduled_at: { type: 'string' as const },
 	auto_trigger: { type: 'boolean' as const },
+	hours_interval: { type: 'number' as const },
 	enabled: { type: 'boolean' as const },
 	notes: { type: 'string' as const },
 	git_ref: { type: 'string' as const },
@@ -153,7 +155,7 @@ export const requestDeployment: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to request deployment');
+		return { result: { error: response.error || 'Failed to request deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -170,7 +172,7 @@ export const claimDeploymentValidation: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to claim deployment validation');
+		return { result: { error: response.error || 'Failed to claim deployment validation' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -188,7 +190,7 @@ export const reportValidation: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to report validation');
+		return { result: { error: response.error || 'Failed to report validation' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -201,7 +203,7 @@ export const checkDeploymentStatus: Handler = async (args, ctx) => {
 	const response = await apiClient.checkDeploymentStatus(project_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to check deployment status');
+		return { result: { error: response.error || 'Failed to check deployment status' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -218,7 +220,7 @@ export const startDeployment: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to start deployment');
+		return { result: { error: response.error || 'Failed to start deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -235,7 +237,7 @@ export const completeDeployment: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to complete deployment');
+		return { result: { error: response.error || 'Failed to complete deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -248,7 +250,7 @@ export const cancelDeployment: Handler = async (args, ctx) => {
 	const response = await apiClient.cancelDeployment(project_id, reason);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to cancel deployment');
+		return { result: { error: response.error || 'Failed to cancel deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -269,7 +271,7 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to add deployment requirement');
+		return { result: { error: response.error || 'Failed to add deployment requirement' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -282,7 +284,7 @@ export const completeDeploymentRequirement: Handler = async (args, ctx) => {
 	const response = await apiClient.completeDeploymentRequirement(requirement_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to complete deployment requirement');
+		return { result: { error: response.error || 'Failed to complete deployment requirement' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -298,7 +300,7 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to get deployment requirements');
+		return { result: { error: response.error || 'Failed to get deployment requirements' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -316,6 +318,7 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 		schedule_type,
 		scheduled_at,
 		auto_trigger,
+		hours_interval,
 		notes,
 		git_ref,
 	} = parseArgs(args, scheduleDeploymentSchema);
@@ -335,19 +338,28 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 		});
 	}
 
+	// Validate hours_interval for hourly schedule type (default is 1)
+	const hoursInterval = hours_interval ?? 1;
+	if (schedule_type === 'hourly' && (hoursInterval < 1 || hoursInterval > 24)) {
+		throw new ValidationError('hours_interval must be between 1 and 24', {
+			field: 'hours_interval',
+		});
+	}
+
 	const apiClient = getApiClient();
 	const response = await apiClient.scheduleDeployment(project_id, {
 		environment: environment as 'development' | 'staging' | 'production',
 		version_bump: version_bump as 'patch' | 'minor' | 'major',
-		schedule_type: schedule_type as 'once' | 'daily' | 'weekly' | 'monthly',
+		schedule_type: schedule_type as 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly',
 		scheduled_at: scheduledDate.toISOString(),
 		auto_trigger,
+		hours_interval: hoursInterval,
 		notes,
 		git_ref
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to schedule deployment');
+		return { result: { error: response.error || 'Failed to schedule deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -360,7 +372,7 @@ export const getScheduledDeployments: Handler = async (args, ctx) => {
 	const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to get scheduled deployments');
+		return { result: { error: response.error || 'Failed to get scheduled deployments' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -374,6 +386,7 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		schedule_type,
 		scheduled_at,
 		auto_trigger,
+		hours_interval,
 		enabled,
 		notes,
 		git_ref,
@@ -394,6 +407,12 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 	}
 
 	if (auto_trigger !== undefined) updates.auto_trigger = auto_trigger;
+	if (hours_interval !== undefined) {
+		if (hours_interval < 1 || hours_interval > 24) {
+			throw new ValidationError('hours_interval must be between 1 and 24');
+		}
+		updates.hours_interval = hours_interval;
+	}
 	if (enabled !== undefined) updates.enabled = enabled;
 	if (notes !== undefined) updates.notes = notes;
 	if (git_ref !== undefined) updates.git_ref = git_ref;
@@ -406,16 +425,17 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 	const response = await apiClient.updateScheduledDeployment(schedule_id, updates as {
 		environment?: 'development' | 'staging' | 'production';
 		version_bump?: 'patch' | 'minor' | 'major';
-		schedule_type?: 'once' | 'daily' | 'weekly' | 'monthly';
+		schedule_type?: 'once' | 'hourly' | 'daily' | 'weekly' | 'monthly';
 		scheduled_at?: string;
 		auto_trigger?: boolean;
+		hours_interval?: number;
 		enabled?: boolean;
 		notes?: string;
 		git_ref?: string;
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to update scheduled deployment');
+		return { result: { error: response.error || 'Failed to update scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -428,7 +448,7 @@ export const deleteScheduledDeployment: Handler = async (args, ctx) => {
 	const response = await apiClient.deleteScheduledDeployment(schedule_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to delete scheduled deployment');
+		return { result: { error: response.error || 'Failed to delete scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -445,7 +465,7 @@ export const triggerScheduledDeployment: Handler = async (args, ctx) => {
 	);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to trigger scheduled deployment');
+		return { result: { error: response.error || 'Failed to trigger scheduled deployment' }, isError: true };
 	}
 
 	return { result: response.data };
@@ -458,7 +478,7 @@ export const checkDueDeployments: Handler = async (args, ctx) => {
 	const response = await apiClient.checkDueDeployments(project_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to check due deployments');
+		return { result: { error: response.error || 'Failed to check due deployments' }, isError: true };
 	}
 
 	return { result: response.data };