@vibescope/mcp-server 0.2.0 → 0.2.1

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();
@@ -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 &&
@@ -134,10 +193,7 @@ export const updateBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -177,16 +233,7 @@ export const getBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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,7 +255,7 @@ 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
 	});
@@ -221,10 +268,7 @@ export const getBodiesOfWork: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -240,17 +284,7 @@ export const deleteBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -275,10 +309,7 @@ export const addTaskToBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -296,10 +327,7 @@ export const removeTaskFromBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -319,18 +347,7 @@ export const activateBodyOfWork: Handler = async (args, ctx) => {
 };
 
 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');
@@ -358,15 +375,7 @@ export const addTaskDependency: Handler = async (args, ctx) => {
 };
 
 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();
 
@@ -387,18 +396,12 @@ export const removeTaskDependency: Handler = async (args, ctx) => {
 };
 
 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');
 	}
 
-	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<{
@@ -421,10 +424,7 @@ export const getTaskDependencies: Handler = async (args, ctx) => {
 };
 
 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();
 

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

@@ -11,27 +11,68 @@
  */
 
 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 },
+};
+
+// 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 +87,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 +106,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,46 +133,28 @@ 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) {
-		return {
-			result: { error: 'No updates provided' },
-			isError: true,
-		};
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.updateCostAlert(alert_id, updates);
 
@@ -169,15 +171,8 @@ export const updateCostAlert: Handler = async (args, ctx) => {
 /**
  * Delete a cost alert
  */
-export const deleteCostAlert: Handler = async (args, ctx) => {
-	const { alert_id } = args as { alert_id: string };
-
-	if (!alert_id) {
-		return {
-			result: { error: 'alert_id is required' },
-			isError: true,
-		};
-	}
+export const deleteCostAlert: Handler = async (args, _ctx) => {
+	const { alert_id } = parseArgs(args, deleteCostAlertSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteCostAlert(alert_id);
@@ -195,18 +190,8 @@ export const deleteCostAlert: Handler = async (args, ctx) => {
 /**
  * Get task costs for a project
  */
-export const getTaskCosts: Handler = async (args, ctx) => {
-	const { project_id, limit = 20 } = args as {
-		project_id: string;
-		limit?: number;
-	};
-
-	if (!project_id) {
-		return {
-			result: { error: 'project_id is required' },
-			isError: true,
-		};
-	}
+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);