@vibescope/mcp-server 0.2.0 → 0.2.2

package/src/handlers/bodies-of-work.test.ts

@@ -109,16 +109,19 @@ describe('createBodyOfWork', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 
-		await expect(
-			createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx)
-		).rejects.toThrow('Failed to create body of work');
+		const result = await createBodyOfWork({ project_id: VALID_UUID, title: 'Test' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Insert failed',
+		});
 	});
 });
 
@@ -201,16 +204,19 @@ describe('getBodyOfWork', () => {
 		await expect(getBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when body of work not found', async () => {
+	it('should return error when body of work not found', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Not found',
 		});
 
-		await expect(
-			getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to get body of work');
+		const result = await getBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Not found',
+		});
 	});
 
 	it('should return body of work with tasks organized by phase', async () => {
@@ -331,16 +337,19 @@ describe('addTaskToBodyOfWork', () => {
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx)
-		).rejects.toThrow('Failed to add task to body of work');
+		const result = await addTaskToBodyOfWork({ body_of_work_id: VALID_UUID, task_id: VALID_UUID_2 }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should add task with default phase "core"', async () => {
@@ -435,16 +444,19 @@ describe('activateBodyOfWork', () => {
 		await expect(activateBodyOfWork({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to activate body of work');
+		const result = await activateBodyOfWork({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should activate body of work successfully', async () => {
@@ -484,15 +496,19 @@ describe('addTaskDependency', () => {
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when task depends on itself', async () => {
+	it('should return error when task depends on itself', async () => {
 		const ctx = createMockContext();
-		await expect(
-			addTaskDependency({
-				body_of_work_id: VALID_UUID,
-				task_id: VALID_UUID_2,
-				depends_on_task_id: VALID_UUID_2,
-			}, ctx)
-		).rejects.toThrow('A task cannot depend on itself');
+
+		const result = await addTaskDependency({
+			body_of_work_id: VALID_UUID,
+			task_id: VALID_UUID_2,
+			depends_on_task_id: VALID_UUID_2,
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'A task cannot depend on itself',
+		});
 	});
 
 	it('should add dependency successfully', async () => {
@@ -572,11 +588,15 @@ describe('removeTaskDependency', () => {
 describe('getTaskDependencies', () => {
 	beforeEach(() => vi.clearAllMocks());
 
-	it('should throw error when neither body_of_work_id nor task_id provided', async () => {
+	it('should return error when neither body_of_work_id nor task_id provided', async () => {
 		const ctx = createMockContext();
-		await expect(getTaskDependencies({}, ctx)).rejects.toThrow(
-			'Either body_of_work_id or task_id is required'
-		);
+
+		const result = await getTaskDependencies({}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Either body_of_work_id or task_id is required',
+		});
 	});
 
 	it('should return dependencies filtered by body_of_work_id', async () => {
@@ -626,16 +646,19 @@ describe('getNextBodyOfWorkTask', () => {
 		await expect(getNextBodyOfWorkTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when API returns error', async () => {
+	it('should return error when API returns error', async () => {
 		const ctx = createMockContext();
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Body of work not found',
 		});
 
-		await expect(
-			getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx)
-		).rejects.toThrow('Failed to get next body of work task');
+		const result = await getNextBodyOfWorkTask({ body_of_work_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({
+			error: 'Body of work not found',
+		});
 	});
 
 	it('should return null when no tasks available', async () => {

package/src/handlers/bodies-of-work.ts

@@ -19,14 +19,96 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-type BodyOfWorkStatus = 'draft' | 'active' | 'completed' | 'cancelled';
-type TaskPhase = 'pre' | 'core' | 'post';
-type DeployEnvironment = 'development' | 'staging' | 'production';
-type VersionBump = 'patch' | 'minor' | 'major';
-type DeployTrigger = 'all_completed' | 'all_completed_validated';
+const BODY_OF_WORK_STATUSES = ['draft', 'active', 'completed', 'cancelled'] as const;
+const TASK_PHASES = ['pre', 'core', 'post'] as const;
+const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'] as const;
+const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
+const DEPLOY_TRIGGERS = ['all_completed', 'all_completed_validated'] as const;
+
+type BodyOfWorkStatus = typeof BODY_OF_WORK_STATUSES[number];
+type TaskPhase = typeof TASK_PHASES[number];
+type DeployEnvironment = typeof DEPLOY_ENVIRONMENTS[number];
+type VersionBump = typeof VERSION_BUMPS[number];
+type DeployTrigger = typeof DEPLOY_TRIGGERS[number];
+
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+
+const createBodyOfWorkSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	auto_deploy_on_completion: { type: 'boolean' as const },
+	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+
+const updateBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	title: { type: 'string' as const },
+	description: { type: 'string' as const },
+	auto_deploy_on_completion: { type: 'boolean' as const },
+	deploy_environment: { type: 'string' as const, validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+	deploy_version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	deploy_trigger: { type: 'string' as const, validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+
+const getBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	summary_only: { type: 'boolean' as const, default: false },
+};
+
+const getBodiesOfWorkSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, validate: createEnumValidator(BODY_OF_WORK_STATUSES) },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+	search_query: { type: 'string' as const },
+};
+
+const deleteBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const addTaskToBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	phase: { type: 'string' as const, validate: createEnumValidator(TASK_PHASES) },
+	order_index: { type: 'number' as const },
+};
+
+const removeTaskFromBodyOfWorkSchema = {
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const activateBodyOfWorkSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const addTaskDependencySchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const removeTaskDependencySchema = {
+	task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	depends_on_task_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getTaskDependenciesSchema = {
+	body_of_work_id: { type: 'string' as const, validate: uuidValidator },
+	task_id: { type: 'string' as const, validate: uuidValidator },
+};
+
+const getNextBodyOfWorkTaskSchema = {
+	body_of_work_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
 
 export const createBodyOfWork: Handler = async (args, ctx) => {
 	const {
@@ -37,19 +119,7 @@ export const createBodyOfWork: Handler = async (args, ctx) => {
 		deploy_environment,
 		deploy_version_bump,
 		deploy_trigger,
-	} = args as {
-		project_id: string;
-		title: string;
-		description?: string;
-		auto_deploy_on_completion?: boolean;
-		deploy_environment?: DeployEnvironment;
-		deploy_version_bump?: VersionBump;
-		deploy_trigger?: DeployTrigger;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(title, 'title');
+	} = parseArgs(args, createBodyOfWorkSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
@@ -72,7 +142,7 @@ export const createBodyOfWork: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to create body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to create body of work' }, isError: true };
 	}
 
 	return {
@@ -95,18 +165,7 @@ export const updateBodyOfWork: Handler = async (args, ctx) => {
 		deploy_environment,
 		deploy_version_bump,
 		deploy_trigger,
-	} = args as {
-		body_of_work_id: string;
-		title?: string;
-		description?: string;
-		auto_deploy_on_completion?: boolean;
-		deploy_environment?: DeployEnvironment;
-		deploy_version_bump?: VersionBump;
-		deploy_trigger?: DeployTrigger;
-	};
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
+	} = parseArgs(args, updateBodyOfWorkSchema);
 
 	// Check if any updates provided
 	if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
@@ -127,17 +186,14 @@ export const updateBodyOfWork: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to update body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to update body of work' }, isError: true };
 	}
 
 	return { result: { success: true, body_of_work_id } };
 };
 
 export const getBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id, summary_only = false } = args as { body_of_work_id: string; summary_only?: boolean };
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
+	const { body_of_work_id, summary_only } = parseArgs(args, getBodyOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -170,23 +226,14 @@ export const getBodyOfWork: Handler = async (args, ctx) => {
 	}>('get_body_of_work', { body_of_work_id, summary_only });
 
 	if (!response.ok) {
-		throw new Error(`Failed to get body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to get body of work' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const getBodiesOfWork: Handler = async (args, ctx) => {
-	const { project_id, status, limit = 50, offset = 0, search_query } = args as {
-		project_id: string;
-		status?: BodyOfWorkStatus;
-		limit?: number;
-		offset?: number;
-		search_query?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, status, limit, offset, search_query } = parseArgs(args, getBodiesOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -208,23 +255,20 @@ export const getBodiesOfWork: Handler = async (args, ctx) => {
 	}>('get_bodies_of_work', {
 		project_id,
 		status,
-		limit: Math.min(limit, 100),
+		limit: Math.min(limit ?? 50, 100),
 		offset,
 		search_query
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to fetch bodies of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to fetch bodies of work' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const deleteBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id } = args as { body_of_work_id: string };
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
+	const { body_of_work_id } = parseArgs(args, deleteBodyOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -233,24 +277,14 @@ export const deleteBodyOfWork: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to delete body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to delete body of work' }, isError: true };
 	}
 
 	return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
 };
 
 export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id, phase, order_index } = args as {
-		body_of_work_id: string;
-		task_id: string;
-		phase?: TaskPhase;
-		order_index?: number;
-	};
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
-	validateRequired(task_id, 'task_id');
-	validateUUID(task_id, 'task_id');
+	const { body_of_work_id, task_id, phase, order_index } = parseArgs(args, addTaskToBodyOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -268,17 +302,14 @@ export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to add task to body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to add task to body of work' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
-	const { task_id } = args as { task_id: string };
-
-	validateRequired(task_id, 'task_id');
-	validateUUID(task_id, 'task_id');
+	const { task_id } = parseArgs(args, removeTaskFromBodyOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -289,17 +320,14 @@ export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
 	}>('remove_task_from_body_of_work', { task_id });
 
 	if (!response.ok) {
-		throw new Error(`Failed to remove task from body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to remove task from body of work' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const activateBodyOfWork: Handler = async (args, ctx) => {
-	const { body_of_work_id } = args as { body_of_work_id: string };
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
+	const { body_of_work_id } = parseArgs(args, activateBodyOfWorkSchema);
 
 	const apiClient = getApiClient();
 
@@ -312,28 +340,17 @@ export const activateBodyOfWork: Handler = async (args, ctx) => {
 	}>('activate_body_of_work', { body_of_work_id });
 
 	if (!response.ok) {
-		throw new Error(`Failed to activate body of work: ${response.error}`);
+		return { result: { error: response.error || 'Failed to activate body of work' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const addTaskDependency: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id, depends_on_task_id } = args as {
-		body_of_work_id: string;
-		task_id: string;
-		depends_on_task_id: string;
-	};
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
-	validateRequired(task_id, 'task_id');
-	validateUUID(task_id, 'task_id');
-	validateRequired(depends_on_task_id, 'depends_on_task_id');
-	validateUUID(depends_on_task_id, 'depends_on_task_id');
+	const { body_of_work_id, task_id, depends_on_task_id } = parseArgs(args, addTaskDependencySchema);
 
 	if (task_id === depends_on_task_id) {
-		throw new Error('A task cannot depend on itself');
+		return { result: { error: 'A task cannot depend on itself' }, isError: true };
 	}
 
 	const apiClient = getApiClient();
@@ -351,22 +368,14 @@ export const addTaskDependency: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to add task dependency: ${response.error}`);
+		return { result: { error: response.error || 'Failed to add task dependency' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const removeTaskDependency: Handler = async (args, ctx) => {
-	const { task_id, depends_on_task_id } = args as {
-		task_id: string;
-		depends_on_task_id: string;
-	};
-
-	validateRequired(task_id, 'task_id');
-	validateUUID(task_id, 'task_id');
-	validateRequired(depends_on_task_id, 'depends_on_task_id');
-	validateUUID(depends_on_task_id, 'depends_on_task_id');
+	const { task_id, depends_on_task_id } = parseArgs(args, removeTaskDependencySchema);
 
 	const apiClient = getApiClient();
 
@@ -380,25 +389,19 @@ export const removeTaskDependency: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to remove task dependency: ${response.error}`);
+		return { result: { error: response.error || 'Failed to remove task dependency' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const getTaskDependencies: Handler = async (args, ctx) => {
-	const { body_of_work_id, task_id } = args as {
-		body_of_work_id?: string;
-		task_id?: string;
-	};
+	const { body_of_work_id, task_id } = parseArgs(args, getTaskDependenciesSchema);
 
 	if (!body_of_work_id && !task_id) {
-		throw new Error('Either body_of_work_id or task_id is required');
+		return { result: { error: 'Either body_of_work_id or task_id is required' }, isError: true };
 	}
 
-	if (body_of_work_id) validateUUID(body_of_work_id, 'body_of_work_id');
-	if (task_id) validateUUID(task_id, 'task_id');
-
 	const apiClient = getApiClient();
 
 	const response = await apiClient.proxy<{
@@ -414,17 +417,14 @@ export const getTaskDependencies: Handler = async (args, ctx) => {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Failed to fetch task dependencies: ${response.error}`);
+		return { result: { error: response.error || 'Failed to fetch task dependencies' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
-	const { body_of_work_id } = args as { body_of_work_id: string };
-
-	validateRequired(body_of_work_id, 'body_of_work_id');
-	validateUUID(body_of_work_id, 'body_of_work_id');
+	const { body_of_work_id } = parseArgs(args, getNextBodyOfWorkTaskSchema);
 
 	const apiClient = getApiClient();
 
@@ -443,7 +443,7 @@ export const getNextBodyOfWorkTask: Handler = async (args, ctx) => {
 	}>('get_next_body_of_work_task', { body_of_work_id });
 
 	if (!response.ok) {
-		throw new Error(`Failed to get next body of work task: ${response.error}`);
+		return { result: { error: response.error || 'Failed to get next body of work task' }, isError: true };
 	}
 
 	return { result: response.data };