@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/decisions.test.ts

@@ -1,95 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import { logDecision, getDecisions, deleteDecision } from './decisions.js';
 import { ValidationError } from '../validators.js';
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	deleteResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-	let currentOperation = 'select';
-	let insertThenSelect = false;
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			if (currentOperation === 'insert') {
-				insertThenSelect = true;
-			} else {
-				currentOperation = 'select';
-				insertThenSelect = false;
-			}
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			currentOperation = 'insert';
-			insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			currentOperation = 'delete';
-			insertThenSelect = false;
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		single: vi.fn(() => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult);
-			}
-			return Promise.resolve(defaultResult);
-		}),
-		then: vi.fn((resolve: (value: unknown) => void) => {
-			if (currentOperation === 'insert' || insertThenSelect) {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'delete') {
-				return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-function createMockContext(
-	supabase: SupabaseClient,
-	options: { sessionId?: string | null } = {}
-): HandlerContext {
-	const defaultTokenUsage: TokenUsage = {
-		callCount: 5,
-		totalTokens: 2500,
-		byTool: {},
-	};
-
-	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
-
-	return {
-		supabase,
-		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
-		session: {
-			instanceId: 'instance-abc',
-			currentSessionId: sessionId,
-			currentPersona: 'Wave',
-			tokenUsage: defaultTokenUsage,
-		},
-		updateSession: vi.fn(),
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // logDecision Tests
@@ -99,126 +12,129 @@ describe('logDecision', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			logDecision({ title: 'Decision', description: 'Description' }, ctx)
+			logDecision({ title: 'Test', description: 'Desc' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			logDecision({ project_id: 'invalid', title: 'Decision', description: 'Description' }, ctx)
+			logDecision({ project_id: 'invalid', title: 'Test', description: 'Desc' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', description: 'Description' }, ctx)
+			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', description: 'Desc' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for missing description', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', title: 'Decision' }, ctx)
+			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', title: 'Test' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
 	it('should log decision successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+		mockApiClient.logDecision.mockResolvedValue({
+			ok: true,
+			data: { decision_id: 'dec-123' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await logDecision(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Use PostgreSQL',
-				description: 'Decided to use PostgreSQL for the database',
+				title: 'Use TypeScript',
+				description: 'We will use TypeScript for type safety',
 			},
 			ctx
 		);
 
 		expect(result.result).toMatchObject({
 			success: true,
-			title: 'Use PostgreSQL',
+			title: 'Use TypeScript',
+			decision_id: 'dec-123',
 		});
 	});
 
 	it('should log decision with rationale and alternatives', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+		mockApiClient.logDecision.mockResolvedValue({
+			ok: true,
+			data: { decision_id: 'dec-456' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await logDecision(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
 				title: 'Use PostgreSQL',
-				description: 'Decided to use PostgreSQL for the database',
-				rationale: 'Better JSON support and reliability',
+				description: 'We will use PostgreSQL as our database',
+				rationale: 'Better JSON support and performance',
 				alternatives_considered: ['MySQL', 'MongoDB'],
 			},
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.logDecision).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
 				title: 'Use PostgreSQL',
-				description: 'Decided to use PostgreSQL for the database',
-				rationale: 'Better JSON support and reliability',
+				description: 'We will use PostgreSQL as our database',
+				rationale: 'Better JSON support and performance',
 				alternatives_considered: ['MySQL', 'MongoDB'],
-				created_by: 'agent',
-				created_by_session_id: 'session-123',
-			})
+			},
+			'session-123'
 		);
 	});
 
-	it('should include session_id in insert', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+	it('should include session_id in API call', async () => {
+		mockApiClient.logDecision.mockResolvedValue({
+			ok: true,
+			data: { decision_id: 'dec-789' },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await logDecision(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Decision',
-				description: 'Description',
+				title: 'Test Decision',
+				description: 'Test description',
 			},
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				created_by: 'agent',
-				created_by_session_id: 'my-session',
-			})
+		expect(mockApiClient.logDecision).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.any(Object),
+			'my-session'
 		);
 	});
 
-	it('should throw error when insert fails', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.logDecision.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
-			logDecision({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'Decision',
-				description: 'Description',
-			}, ctx)
+			logDecision(
+				{
+					project_id: '123e4567-e89b-12d3-a456-426614174000',
+					title: 'Test',
+					description: 'Test',
+				},
+				ctx
+			)
 		).rejects.toThrow('Failed to log decision: Insert failed');
 	});
 });
@@ -231,15 +147,13 @@ describe('getDecisions', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getDecisions({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			getDecisions({ project_id: 'invalid' }, ctx)
@@ -247,10 +161,11 @@ describe('getDecisions', () => {
 	});
 
 	it('should return empty list when no decisions', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getDecisions.mockResolvedValue({
+			ok: true,
+			data: { decisions: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getDecisions(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -264,65 +179,55 @@ describe('getDecisions', () => {
 
 	it('should return decisions list', async () => {
 		const mockDecisions = [
-			{ id: 'd1', title: 'Decision 1', description: 'Desc 1', created_at: '2025-01-14T10:00:00Z' },
-			{ id: 'd2', title: 'Decision 2', description: 'Desc 2', created_at: '2025-01-14T11:00:00Z' },
+			{ id: 'd1', title: 'Decision 1', description: 'Desc 1' },
+			{ id: 'd2', title: 'Decision 2', description: 'Desc 2' },
 		];
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockDecisions, error: null },
+		mockApiClient.getDecisions.mockResolvedValue({
+			ok: true,
+			data: { decisions: mockDecisions },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getDecisions(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect((result.result as { decisions: unknown[] }).decisions).toHaveLength(2);
-	});
-
-	it('should query decisions table', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		expect(result.result).toMatchObject({
+			decisions: mockDecisions,
 		});
-		const ctx = createMockContext(supabase);
-
-		await getDecisions(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
-		);
-
-		expect(supabase.from).toHaveBeenCalledWith('decisions');
 	});
 
-	it('should order by created_at descending', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should call API client getDecisions', async () => {
+		mockApiClient.getDecisions.mockResolvedValue({
+			ok: true,
+			data: { decisions: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getDecisions(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.order).toHaveBeenCalledWith('created_at', { ascending: false });
+		expect(mockApiClient.getDecisions).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000'
+		);
 	});
 
 	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']>);
+		mockApiClient.getDecisions.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
-			getDecisions({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to fetch decisions');
+			getDecisions(
+				{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+				ctx
+			)
+		).rejects.toThrow('Failed to fetch decisions: Query failed');
 	});
 });
 
@@ -334,15 +239,13 @@ describe('deleteDecision', () => {
 	beforeEach(() => vi.clearAllMocks());
 
 	it('should throw error for missing decision_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(deleteDecision({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid decision_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			deleteDecision({ decision_id: 'invalid' }, ctx)
@@ -350,10 +253,11 @@ describe('deleteDecision', () => {
 	});
 
 	it('should delete decision successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.deleteDecision.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await deleteDecision(
 			{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -365,37 +269,35 @@ describe('deleteDecision', () => {
 		});
 	});
 
-	it('should call delete on decisions table', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+	it('should call API client deleteDecision', async () => {
+		mockApiClient.deleteDecision.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await deleteDecision(
 			{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('decisions');
-		expect(supabase.delete).toHaveBeenCalled();
-		expect(supabase.eq).toHaveBeenCalledWith('id', '123e4567-e89b-12d3-a456-426614174000');
+		expect(mockApiClient.deleteDecision).toHaveBeenCalledWith(
+			'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']>);
+		mockApiClient.deleteDecision.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
-			deleteDecision({ decision_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to delete decision');
+			deleteDecision(
+				{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
+				ctx
+			)
+		).rejects.toThrow('Failed to delete decision: Delete failed');
 	});
 });

package/src/handlers/decisions.ts

@@ -5,10 +5,13 @@
  * - log_decision
  * - get_decisions
  * - delete_decision
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 
 export const logDecision: Handler = async (args, ctx) => {
 	const { project_id, title, description, rationale, alternatives_considered } = args as {
@@ -24,40 +27,44 @@ export const logDecision: Handler = async (args, ctx) => {
 	validateRequired(title, 'title');
 	validateRequired(description, 'description');
 
-	const { supabase, session } = ctx;
+	const { session } = ctx;
+	const apiClient = getApiClient();
 
-	const { error } = await supabase
-		.from('decisions')
-		.insert({
-			project_id,
-			title,
-			description,
-			rationale: rationale || null,
-			alternatives_considered: alternatives_considered || null,
-			created_by: 'agent',
-			created_by_session_id: session.currentSessionId,
-		});
+	const response = await apiClient.logDecision(project_id, {
+		title,
+		description,
+		rationale,
+		alternatives_considered
+	}, session.currentSessionId || undefined);
 
-	if (error) throw new Error(`Failed to log decision: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to log decision: ${response.error}`);
+	}
 
-	return { result: { success: true, title } };
+	return { result: { success: true, title, decision_id: response.data?.decision_id } };
 };
 
 export const getDecisions: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = args as {
+		project_id: string;
+	};
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { data, error } = await ctx.supabase
-		.from('decisions')
-		.select('id, title, description, rationale, created_at')
-		.eq('project_id', project_id)
-		.order('created_at', { ascending: false });
+	const apiClient = getApiClient();
 
-	if (error) throw new Error(`Failed to fetch decisions: ${error.message}`);
+	const response = await apiClient.getDecisions(project_id);
 
-	return { result: { decisions: data || [] } };
+	if (!response.ok) {
+		throw new Error(`Failed to fetch decisions: ${response.error}`);
+	}
+
+	return {
+		result: {
+			decisions: response.data?.decisions || [],
+		},
+	};
 };
 
 export const deleteDecision: Handler = async (args, ctx) => {
@@ -66,12 +73,13 @@ export const deleteDecision: Handler = async (args, ctx) => {
 	validateRequired(decision_id, 'decision_id');
 	validateUUID(decision_id, 'decision_id');
 
-	const { error } = await ctx.supabase
-		.from('decisions')
-		.delete()
-		.eq('id', decision_id);
+	const apiClient = getApiClient();
+
+	const response = await apiClient.deleteDecision(decision_id);
 
-	if (error) throw new Error(`Failed to delete decision: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to delete decision: ${response.error}`);
+	}
 
 	return { result: { success: true } };
 };