@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/blockers.ts

@@ -9,94 +9,92 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import {
+	parseArgs,
+	uuidValidator,
+	createEnumValidator,
+	VALID_BLOCKER_STATUSES,
+} from '../validators.js';
+import { getApiClient } from '../api-client.js';
+
+// Argument schemas for type-safe parsing
+const addBlockerSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	description: { type: 'string' as const, required: true as const },
+};
 
-export const addBlocker: Handler = async (args, ctx) => {
-	const { project_id, description } = args as {
-		project_id: string;
-		description: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(description, 'description');
-
-	const { supabase, session } = ctx;
-
-	const { data, error } = await supabase
-		.from('blockers')
-		.insert({
-			project_id,
-			description,
-			created_by: 'agent',
-			created_by_session_id: session.currentSessionId,
-		})
-		.select('id')
-		.single();
-
-	if (error) throw new Error(`Failed to add blocker: ${error.message}`);
-
-	return { result: { success: true, blocker_id: data.id } };
+const resolveBlockerSchema = {
+	blocker_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	resolution_note: { type: 'string' as const },
 };
 
-export const resolveBlocker: Handler = async (args, ctx) => {
-	const { blocker_id, resolution_note } = args as {
-		blocker_id: string;
-		resolution_note?: string;
-	};
+const getBlockersSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, default: 'open', validate: createEnumValidator(VALID_BLOCKER_STATUSES) },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+	search_query: { type: 'string' as const },
+};
 
-	validateRequired(blocker_id, 'blocker_id');
-	validateUUID(blocker_id, 'blocker_id');
+const deleteBlockerSchema = {
+	blocker_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
 
-	const { error } = await ctx.supabase
-		.from('blockers')
-		.update({
-			status: 'resolved',
-			resolved_at: new Date().toISOString(),
-			resolution_note: resolution_note || null,
-		})
-		.eq('id', blocker_id);
+export const addBlocker: Handler = async (args, ctx) => {
+	const { project_id, description } = parseArgs(args, addBlockerSchema);
 
-	if (error) throw new Error(`Failed to resolve blocker: ${error.message}`);
+	const apiClient = getApiClient();
+	const response = await apiClient.addBlocker(project_id, description, ctx.session.currentSessionId || undefined);
 
-	return { result: { success: true, blocker_id } };
-};
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to add blocker');
+	}
 
-export const getBlockers: Handler = async (args, ctx) => {
-	const { project_id, status = 'open' } = args as {
-		project_id: string;
-		status?: string;
-	};
+	return { result: response.data };
+};
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+export const resolveBlocker: Handler = async (args, _ctx) => {
+	const { blocker_id, resolution_note } = parseArgs(args, resolveBlockerSchema);
 
-	const { data, error } = await ctx.supabase
-		.from('blockers')
-		.select('id, description, status, created_at, resolved_at, resolution_note')
-		.eq('project_id', project_id)
-		.eq('status', status)
-		.order('created_at', { ascending: false });
+	const apiClient = getApiClient();
+	const response = await apiClient.resolveBlocker(blocker_id, resolution_note);
 
-	if (error) throw new Error(`Failed to fetch blockers: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to resolve blocker');
+	}
 
-	return { result: { blockers: data || [] } };
+	return { result: response.data };
 };
 
-export const deleteBlocker: Handler = async (args, ctx) => {
-	const { blocker_id } = args as { blocker_id: string };
+export const getBlockers: Handler = async (args, _ctx) => {
+	const { project_id, status, limit, offset, search_query } = parseArgs(args, getBlockersSchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getBlockers(project_id, {
+		status,
+		limit,
+		offset,
+		search_query
+	});
+
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to fetch blockers');
+	}
+
+	return { result: response.data };
+};
 
-	validateRequired(blocker_id, 'blocker_id');
-	validateUUID(blocker_id, 'blocker_id');
+export const deleteBlocker: Handler = async (args, _ctx) => {
+	const { blocker_id } = parseArgs(args, deleteBlockerSchema);
 
-	const { error } = await ctx.supabase
-		.from('blockers')
-		.delete()
-		.eq('id', blocker_id);
+	const apiClient = getApiClient();
+	const response = await apiClient.deleteBlocker(blocker_id);
 
-	if (error) throw new Error(`Failed to delete blocker: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(response.error || 'Failed to delete blocker');
+	}
 
-	return { result: { success: true } };
+	return { result: response.data };
 };
 
 /**