@vibescope/mcp-server 0.0.1

package/src/handlers/blockers.test.ts

@@ -0,0 +1,390 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	addBlocker,
+	resolveBlocker,
+	getBlockers,
+	deleteBlocker,
+} from './blockers.js';
+import { ValidationError } from '../validators.js';
+import { createMockSupabase, createMockContext } from './__test-utils__.js';
+
+// ============================================================================
+// addBlocker Tests
+// ============================================================================
+
+describe('addBlocker', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addBlocker({ description: 'Some blocker' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addBlocker({ project_id: 'invalid', description: 'Some blocker' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing description', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addBlocker({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should add blocker successfully', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'blocker-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await addBlocker(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				description: 'API is down',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			blocker_id: 'blocker-1',
+		});
+	});
+
+	it('should include session_id in insert', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'blocker-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await addBlocker(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				description: 'Blocked by dependency',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				created_by: 'agent',
+				created_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should throw error when insert fails', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: { message: 'Insert failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addBlocker({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				description: 'Test blocker',
+			}, ctx)
+		).rejects.toThrow('Failed to add blocker: Insert failed');
+	});
+});
+
+// ============================================================================
+// resolveBlocker Tests
+// ============================================================================
+
+describe('resolveBlocker', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing blocker_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(resolveBlocker({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid blocker_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			resolveBlocker({ blocker_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should resolve blocker successfully', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await resolveBlocker(
+			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			blocker_id: '123e4567-e89b-12d3-a456-426614174000',
+		});
+	});
+
+	it('should resolve blocker with resolution note', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await resolveBlocker(
+			{
+				blocker_id: '123e4567-e89b-12d3-a456-426614174000',
+				resolution_note: 'Fixed by upgrading dependency',
+			},
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				status: 'resolved',
+				resolution_note: 'Fixed by upgrading dependency',
+			})
+		);
+	});
+
+	it('should set resolved_at timestamp', async () => {
+		const supabase = createMockSupabase({
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await resolveBlocker(
+			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				resolved_at: expect.any(String),
+			})
+		);
+	});
+
+	it('should throw error when update fails', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		// Override update to return error
+		vi.mocked(supabase.from('').update).mockReturnValue({
+			...supabase,
+			eq: vi.fn().mockReturnValue({
+				then: (resolve: (val: unknown) => void) =>
+					Promise.resolve({ data: null, error: { message: 'Update failed' } }).then(resolve),
+			}),
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		await expect(
+			resolveBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to resolve blocker');
+	});
+});
+
+// ============================================================================
+// getBlockers Tests
+// ============================================================================
+
+describe('getBlockers', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getBlockers({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getBlockers({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no blockers', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getBlockers(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			blockers: [],
+		});
+	});
+
+	it('should return blockers list', async () => {
+		const mockBlockers = [
+			{ id: 'b1', description: 'Blocker 1', status: 'open', created_at: '2025-01-14T10:00:00Z' },
+			{ id: 'b2', description: 'Blocker 2', status: 'open', created_at: '2025-01-14T11:00:00Z' },
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockBlockers, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getBlockers(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { blockers: unknown[] }).blockers).toHaveLength(2);
+	});
+
+	it('should filter by status (default: open)', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getBlockers(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.eq).toHaveBeenCalledWith('status', 'open');
+	});
+
+	it('should filter by custom status', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getBlockers(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'resolved' },
+			ctx
+		);
+
+		expect(supabase.eq).toHaveBeenCalledWith('status', 'resolved');
+	});
+
+	it('should query blockers table', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getBlockers(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('blockers');
+	});
+
+	it('should throw error when query fails', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		// Override to return error
+		vi.mocked(supabase.from('').select).mockReturnValue({
+			...supabase,
+			then: (resolve: (val: unknown) => void) =>
+				Promise.resolve({ data: null, error: { message: 'Query failed' } }).then(resolve),
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		await expect(
+			getBlockers({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to fetch blockers');
+	});
+});
+
+// ============================================================================
+// deleteBlocker Tests
+// ============================================================================
+
+describe('deleteBlocker', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing blocker_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(deleteBlocker({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid blocker_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			deleteBlocker({ blocker_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete blocker successfully', async () => {
+		const supabase = createMockSupabase({
+			deleteResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await deleteBlocker(
+			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+	});
+
+	it('should call delete on blockers table', async () => {
+		const supabase = createMockSupabase({
+			deleteResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await deleteBlocker(
+			{ blocker_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('blockers');
+		expect(supabase.delete).toHaveBeenCalled();
+		expect(supabase.eq).toHaveBeenCalledWith('id', '123e4567-e89b-12d3-a456-426614174000');
+	});
+
+	it('should throw error when delete fails', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		// Override delete to return error
+		vi.mocked(supabase.from('').delete).mockReturnValue({
+			...supabase,
+			eq: vi.fn().mockReturnValue({
+				then: (resolve: (val: unknown) => void) =>
+					Promise.resolve({ data: null, error: { message: 'Delete failed' } }).then(resolve),
+			}),
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		await expect(
+			deleteBlocker({ blocker_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to delete blocker');
+	});
+});

package/src/handlers/blockers.ts

@@ -0,0 +1,110 @@
+/**
+ * Blockers Handlers
+ *
+ * Handles blocker management:
+ * - add_blocker
+ * - resolve_blocker
+ * - get_blockers
+ * - delete_blocker
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { validateRequired, validateUUID } from '../validators.js';
+
+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 } };
+};
+
+export const resolveBlocker: Handler = async (args, ctx) => {
+	const { blocker_id, resolution_note } = args as {
+		blocker_id: string;
+		resolution_note?: string;
+	};
+
+	validateRequired(blocker_id, 'blocker_id');
+	validateUUID(blocker_id, 'blocker_id');
+
+	const { error } = await ctx.supabase
+		.from('blockers')
+		.update({
+			status: 'resolved',
+			resolved_at: new Date().toISOString(),
+			resolution_note: resolution_note || null,
+		})
+		.eq('id', blocker_id);
+
+	if (error) throw new Error(`Failed to resolve blocker: ${error.message}`);
+
+	return { result: { success: true, blocker_id } };
+};
+
+export const getBlockers: Handler = async (args, ctx) => {
+	const { project_id, status = 'open' } = args as {
+		project_id: string;
+		status?: string;
+	};
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+
+	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 });
+
+	if (error) throw new Error(`Failed to fetch blockers: ${error.message}`);
+
+	return { result: { blockers: data || [] } };
+};
+
+export const deleteBlocker: Handler = async (args, ctx) => {
+	const { blocker_id } = args as { blocker_id: string };
+
+	validateRequired(blocker_id, 'blocker_id');
+	validateUUID(blocker_id, 'blocker_id');
+
+	const { error } = await ctx.supabase
+		.from('blockers')
+		.delete()
+		.eq('id', blocker_id);
+
+	if (error) throw new Error(`Failed to delete blocker: ${error.message}`);
+
+	return { result: { success: true } };
+};
+
+/**
+ * Blockers handlers registry
+ */
+export const blockerHandlers: HandlerRegistry = {
+	add_blocker: addBlocker,
+	resolve_blocker: resolveBlocker,
+	get_blockers: getBlockers,
+	delete_blocker: deleteBlocker,
+};