@vibescope/mcp-server 0.1.0 → 0.2.1

package/src/handlers/deployment.ts

@@ -17,34 +17,132 @@
 import type { Handler, HandlerRegistry } from './types.js';
 import {
 	ValidationError,
-	validateRequired,
-	validateUUID,
-	validateEnvironment,
+	parseArgs,
+	uuidValidator,
+	createEnumValidator,
 } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const requestDeployment: Handler = async (args, ctx) => {
-	const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: 'patch' | 'minor' | 'major';
-		notes?: string;
-		git_ref?: string;
-	};
+const ENVIRONMENTS = ['development', 'staging', 'production'] as const;
+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 { session } = ctx;
+type Environment = typeof ENVIRONMENTS[number];
+type VersionBump = typeof VERSION_BUMPS[number];
+type RequirementType = typeof REQUIREMENT_TYPES[number];
+type RequirementStage = typeof REQUIREMENT_STAGES[number];
+type RequirementStatus = typeof REQUIREMENT_STATUSES[number];
+type ScheduleType = typeof SCHEDULE_TYPES[number];
+
+// ============================================================================
+// Argument Schemas
+// ============================================================================
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateEnvironment(environment);
+const requestDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
 
-	if (version_bump && !['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-			hint: 'Must be one of: patch, minor, major',
-		});
-	}
+const claimDeploymentValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const reportValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	build_passed: { type: 'boolean' as const, required: true as const },
+	tests_passed: { type: 'boolean' as const },
+	error_message: { type: 'string' as const },
+};
+
+const checkDeploymentStatusSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const startDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const completeDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	success: { type: 'boolean' as const, required: true as const },
+	summary: { type: 'string' as const },
+};
+
+const cancelDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	reason: { type: 'string' as const },
+};
+
+const addDeploymentRequirementSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	type: { type: 'string' as const, required: true as const, validate: createEnumValidator(REQUIREMENT_TYPES) },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	file_path: { type: 'string' as const },
+	stage: { type: 'string' as const, default: 'preparation', validate: createEnumValidator(REQUIREMENT_STAGES) },
+	blocking: { type: 'boolean' as const, default: false },
+	recurring: { type: 'boolean' as const, default: false },
+};
+
+const completeDeploymentRequirementSchema = {
+	requirement_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getDeploymentRequirementsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, default: 'pending', validate: createEnumValidator(REQUIREMENT_STATUSES) },
+	stage: { type: 'string' as const, validate: createEnumValidator([...REQUIREMENT_STAGES, 'all'] as const) },
+};
+
+const scheduleDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	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 },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const getScheduledDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	include_disabled: { type: 'boolean' as const, default: false },
+};
+
+const updateScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	schedule_type: { type: 'string' as const, validate: createEnumValidator(SCHEDULE_TYPES) },
+	scheduled_at: { type: 'string' as const },
+	auto_trigger: { type: 'boolean' as const },
+	enabled: { type: 'boolean' as const },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const deleteScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const triggerScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const checkDueDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const requestDeployment: Handler = async (args, ctx) => {
+	const { project_id, environment, version_bump, notes, git_ref } = parseArgs(args, requestDeploymentSchema);
+	const { session } = ctx;
 
 	const apiClient = getApiClient();
 	const response = await apiClient.requestDeployment(project_id, {
@@ -62,12 +160,9 @@ export const requestDeployment: Handler = async (args, ctx) => {
 };
 
 export const claimDeploymentValidation: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, claimDeploymentValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.claimDeploymentValidation(
 		project_id,
@@ -82,24 +177,9 @@ export const claimDeploymentValidation: Handler = async (args, ctx) => {
 };
 
 export const reportValidation: Handler = async (args, ctx) => {
-	const { project_id, build_passed, tests_passed, error_message } = args as {
-		project_id: string;
-		build_passed: boolean;
-		tests_passed?: boolean;
-		error_message?: string;
-	};
-
+	const { project_id, build_passed, tests_passed, error_message } = parseArgs(args, reportValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (build_passed === undefined) {
-		throw new ValidationError('build_passed is required', {
-			field: 'build_passed',
-			hint: 'Set to true if the build succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.reportValidation(project_id, {
 		build_passed,
@@ -115,10 +195,7 @@ export const reportValidation: Handler = async (args, ctx) => {
 };
 
 export const checkDeploymentStatus: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDeploymentStatusSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDeploymentStatus(project_id);
@@ -131,12 +208,9 @@ export const checkDeploymentStatus: Handler = async (args, ctx) => {
 };
 
 export const startDeployment: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, startDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.startDeployment(
 		project_id,
@@ -151,23 +225,9 @@ export const startDeployment: Handler = async (args, ctx) => {
 };
 
 export const completeDeployment: Handler = async (args, ctx) => {
-	const { project_id, success, summary } = args as {
-		project_id: string;
-		success: boolean;
-		summary?: string;
-	};
-
+	const { project_id, success, summary } = parseArgs(args, completeDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (success === undefined) {
-		throw new ValidationError('success is required', {
-			field: 'success',
-			hint: 'Set to true if deployment succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeployment(project_id, {
 		success,
@@ -182,10 +242,7 @@ export const completeDeployment: Handler = async (args, ctx) => {
 };
 
 export const cancelDeployment: Handler = async (args, ctx) => {
-	const { project_id, reason } = args as { project_id: string; reason?: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, reason } = parseArgs(args, cancelDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.cancelDeployment(project_id, reason);
@@ -198,30 +255,7 @@ export const cancelDeployment: Handler = async (args, ctx) => {
 };
 
 export const addDeploymentRequirement: Handler = async (args, ctx) => {
-	const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false } = args as {
-		project_id: string;
-		type: string;
-		title: string;
-		description?: string;
-		file_path?: string;
-		stage?: string;
-		blocking?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(type, 'type');
-	validateRequired(title, 'title');
-
-	const validTypes = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
-	if (!validTypes.includes(type)) {
-		throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`);
-	}
-
-	const validStages = ['preparation', 'deployment', 'verification'];
-	if (!validStages.includes(stage)) {
-		throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
-	}
+	const { project_id, type, title, description, file_path, stage, blocking, recurring } = parseArgs(args, addDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.addDeploymentRequirement(project_id, {
@@ -230,7 +264,8 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 		description,
 		file_path,
 		stage: stage as 'preparation' | 'deployment' | 'verification',
-		blocking
+		blocking,
+		recurring
 	});
 
 	if (!response.ok) {
@@ -241,10 +276,7 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 };
 
 export const completeDeploymentRequirement: Handler = async (args, ctx) => {
-	const { requirement_id } = args as { requirement_id: string };
-
-	validateRequired(requirement_id, 'requirement_id');
-	validateUUID(requirement_id, 'requirement_id');
+	const { requirement_id } = parseArgs(args, completeDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeploymentRequirement(requirement_id);
@@ -257,14 +289,7 @@ export const completeDeploymentRequirement: Handler = async (args, ctx) => {
 };
 
 export const getDeploymentRequirements: Handler = async (args, ctx) => {
-	const { project_id, status = 'pending', stage } = args as {
-		project_id: string;
-		status?: string;
-		stage?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, status, stage } = parseArgs(args, getDeploymentRequirementsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getDeploymentRequirements(project_id, {
@@ -286,42 +311,14 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 export const scheduleDeployment: Handler = async (args, ctx) => {
 	const {
 		project_id,
-		environment = 'production',
-		version_bump = 'patch',
-		schedule_type = 'once',
+		environment,
+		version_bump,
+		schedule_type,
 		scheduled_at,
-		auto_trigger = true,
+		auto_trigger,
 		notes,
 		git_ref,
-	} = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at: string;
-		auto_trigger?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(scheduled_at, 'scheduled_at');
-	validateEnvironment(environment);
-
-	if (!['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-		});
-	}
-
-	if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-		throw new ValidationError('Invalid schedule_type value', {
-			field: 'schedule_type',
-			validValues: ['once', 'daily', 'weekly', 'monthly'],
-		});
-	}
+	} = parseArgs(args, scheduleDeploymentSchema);
 
 	// Parse and validate scheduled_at
 	const scheduledDate = new Date(scheduled_at);
@@ -357,13 +354,7 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 };
 
 export const getScheduledDeployments: Handler = async (args, ctx) => {
-	const { project_id, include_disabled = false } = args as {
-		project_id: string;
-		include_disabled?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, include_disabled } = parseArgs(args, getScheduledDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
@@ -386,41 +377,13 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		enabled,
 		notes,
 		git_ref,
-	} = args as {
-		schedule_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at?: string;
-		auto_trigger?: boolean;
-		enabled?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	} = parseArgs(args, updateScheduledDeploymentSchema);
 
 	const updates: Record<string, unknown> = {};
 
-	if (environment !== undefined) {
-		validateEnvironment(environment);
-		updates.environment = environment;
-	}
-
-	if (version_bump !== undefined) {
-		if (!['patch', 'minor', 'major'].includes(version_bump)) {
-			throw new ValidationError('Invalid version_bump value');
-		}
-		updates.version_bump = version_bump;
-	}
-
-	if (schedule_type !== undefined) {
-		if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-			throw new ValidationError('Invalid schedule_type value');
-		}
-		updates.schedule_type = schedule_type;
-	}
+	if (environment !== undefined) updates.environment = environment;
+	if (version_bump !== undefined) updates.version_bump = version_bump;
+	if (schedule_type !== undefined) updates.schedule_type = schedule_type;
 
 	if (scheduled_at !== undefined) {
 		const scheduledDate = new Date(scheduled_at);
@@ -459,10 +422,7 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const deleteScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	const { schedule_id } = parseArgs(args, deleteScheduledDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteScheduledDeployment(schedule_id);
@@ -475,12 +435,9 @@ export const deleteScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const triggerScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
+	const { schedule_id } = parseArgs(args, triggerScheduledDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.triggerScheduledDeployment(
 		schedule_id,
@@ -495,10 +452,7 @@ export const triggerScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const checkDueDeployments: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDueDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDueDeployments(project_id);

package/src/handlers/discovery.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { discoverTools, getToolInfo } from './discovery.js';
 import { createMockContext } from './__test-utils__.js';
+import { ValidationError } from '../validators.js';
 
 // ============================================================================
 // discoverTools Tests
@@ -113,13 +114,11 @@ describe('discoverTools', () => {
 // ============================================================================
 
 describe('getToolInfo', () => {
-	it('should return error for missing tool_name', async () => {
+	it('should throw ValidationError for missing tool_name', async () => {
 		const ctx = createMockContext();
 
-		const result = await getToolInfo({}, ctx);
-		const res = result.result as { error: string };
-
-		expect(res.error).toBe('tool_name is required');
+		await expect(getToolInfo({}, ctx)).rejects.toThrow(ValidationError);
+		await expect(getToolInfo({}, ctx)).rejects.toThrow('Missing required field: tool_name');
 	});
 
 	it('should return error for unknown tool', async () => {