@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/progress.test.ts

@@ -1,85 +1,24 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import { logProgress, getActivityFeed } from './progress.js';
 import { ValidationError } from '../validators.js';
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-} = {}) {
-	const defaultResult = { data: null, error: null };
-	let currentOperation = 'select';
-
-	const mock = {
-		from: vi.fn().mockReturnThis(),
-		select: vi.fn(() => {
-			currentOperation = 'select';
-			return mock;
-		}),
-		insert: vi.fn(() => {
-			currentOperation = 'insert';
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		gt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		then: vi.fn((resolve: (value: unknown) => void) => {
-			if (currentOperation === 'insert') {
-				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
-			}
-			if (currentOperation === 'select') {
-				return Promise.resolve(overrides.selectResult ?? 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';
 
 // ============================================================================
 // logProgress Tests
 // ============================================================================
 
 describe('logProgress', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
 
 	it('should log progress successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+		mockApiClient.logProgress.mockResolvedValue({
+			ok: true,
+			data: { progress_id: 'prog-123' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await logProgress(
 			{
@@ -91,14 +30,16 @@ describe('logProgress', () => {
 
 		expect(result.result).toMatchObject({
 			success: true,
+			progress_id: 'prog-123',
 		});
 	});
 
 	it('should log progress with task_id and details', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+		mockApiClient.logProgress.mockResolvedValue({
+			ok: true,
+			data: { progress_id: 'prog-456' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await logProgress(
 			{
@@ -110,23 +51,23 @@ describe('logProgress', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				task_id: '456e4567-e89b-12d3-a456-426614174000',
+		expect(mockApiClient.logProgress).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
 				summary: 'Working on feature',
 				details: 'Added the main component and started styling',
-				created_by: 'agent',
-				created_by_session_id: 'session-123',
-			})
+				task_id: '456e4567-e89b-12d3-a456-426614174000',
+				session_id: 'session-123',
+			}
 		);
 	});
 
-	it('should include session_id in insert', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+	it('should include session_id in request', async () => {
+		mockApiClient.logProgress.mockResolvedValue({
+			ok: true,
+			data: { progress_id: 'prog-789' },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await logProgress(
 			{
@@ -136,19 +77,20 @@ describe('logProgress', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
+		expect(mockApiClient.logProgress).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
 			expect.objectContaining({
-				created_by: 'agent',
-				created_by_session_id: 'my-session',
+				session_id: 'my-session',
 			})
 		);
 	});
 
-	it('should query progress_logs table', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
+	it('should call API client logProgress', async () => {
+		mockApiClient.logProgress.mockResolvedValue({
+			ok: true,
+			data: { progress_id: 'prog-abc' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await logProgress(
 			{
@@ -158,14 +100,15 @@ describe('logProgress', () => {
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('progress_logs');
+		expect(mockApiClient.logProgress).toHaveBeenCalled();
 	});
 
-	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.logProgress.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			logProgress({
@@ -174,6 +117,30 @@ describe('logProgress', () => {
 			}, ctx)
 		).rejects.toThrow('Failed to log progress: Insert failed');
 	});
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			logProgress({ summary: 'Progress' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			logProgress({ project_id: 'invalid', summary: 'Progress' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing summary', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			logProgress({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
 });
 
 // ============================================================================
@@ -181,18 +148,18 @@ describe('logProgress', () => {
 // ============================================================================
 
 describe('getActivityFeed', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getActivityFeed({}, 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(
 			getActivityFeed({ project_id: 'invalid' }, ctx)
@@ -200,10 +167,11 @@ describe('getActivityFeed', () => {
 	});
 
 	it('should return empty activities when no data', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getActivityFeed.mockResolvedValue({
+			ok: true,
+			data: { activities: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getActivityFeed(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -215,50 +183,33 @@ describe('getActivityFeed', () => {
 		});
 	});
 
-	it('should query all activity types by default', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should return activities from API', async () => {
+		const mockActivities = [
+			{ id: 'a1', type: 'task', created_at: '2025-01-14T10:00:00Z' },
+			{ id: 'a2', type: 'progress', created_at: '2025-01-14T11:00:00Z' },
+		];
+		mockApiClient.getActivityFeed.mockResolvedValue({
+			ok: true,
+			data: { activities: mockActivities },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getActivityFeed(
+		const result = await getActivityFeed(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		// Should query tasks, progress_logs, blockers, decisions
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
-		expect(supabase.from).toHaveBeenCalledWith('progress_logs');
-		expect(supabase.from).toHaveBeenCalledWith('blockers');
-		expect(supabase.from).toHaveBeenCalledWith('decisions');
-	});
-
-	it('should filter by specific types', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		expect(result.result).toMatchObject({
+			activities: mockActivities,
 		});
-		const ctx = createMockContext(supabase);
-
-		await getActivityFeed(
-			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				types: ['task', 'blocker'],
-			},
-			ctx
-		);
-
-		// Should only query tasks and blockers
-		expect(supabase.from).toHaveBeenCalledWith('tasks');
-		expect(supabase.from).toHaveBeenCalledWith('blockers');
-		expect(supabase.from).not.toHaveBeenCalledWith('progress_logs');
-		expect(supabase.from).not.toHaveBeenCalledWith('decisions');
 	});
 
-	it('should respect limit parameter', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass limit parameter to API', async () => {
+		mockApiClient.getActivityFeed.mockResolvedValue({
+			ok: true,
+			data: { activities: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getActivityFeed(
 			{
@@ -268,16 +219,20 @@ describe('getActivityFeed', () => {
 			ctx
 		);
 
-		expect(supabase.limit).toHaveBeenCalled();
+		expect(mockApiClient.getActivityFeed).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ limit: 10 })
+		);
 	});
 
 	it('should cap limit at 200', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getActivityFeed.mockResolvedValue({
+			ok: true,
+			data: { activities: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await getActivityFeed(
+		await getActivityFeed(
 			{
 				project_id: '123e4567-e89b-12d3-a456-426614174000',
 				limit: 500,
@@ -285,85 +240,24 @@ describe('getActivityFeed', () => {
 			ctx
 		);
 
-		// Should return at most 200 items
-		expect((result.result as { activities: unknown[] }).activities.length).toBeLessThanOrEqual(200);
-	});
-
-	it('should sort activities by created_at descending', async () => {
-		const mockTasks = [
-			{ id: 't1', title: 'Task 1', status: 'pending', created_by: 'agent', created_at: '2025-01-14T10:00:00Z' },
-		];
-		const mockProgress = [
-			{ id: 'p1', summary: 'Progress 1', created_by: 'agent', created_at: '2025-01-14T11:00:00Z' },
-		];
-
-		let callCount = 0;
-		const supabase = {
-			from: vi.fn().mockReturnThis(),
-			select: vi.fn().mockReturnThis(),
-			eq: vi.fn().mockReturnThis(),
-			gt: vi.fn().mockReturnThis(),
-			order: vi.fn().mockReturnThis(),
-			limit: vi.fn().mockReturnThis(),
-			then: vi.fn((resolve: (val: unknown) => void) => {
-				callCount++;
-				if (callCount === 1) {
-					return Promise.resolve({ data: mockTasks, error: null }).then(resolve);
-				}
-				if (callCount === 2) {
-					return Promise.resolve({ data: mockProgress, error: null }).then(resolve);
-				}
-				return Promise.resolve({ data: [], error: null }).then(resolve);
-			}),
-		} as unknown as SupabaseClient;
-
-		const ctx = createMockContext(supabase);
-
-		const result = await getActivityFeed(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
+		expect(mockApiClient.getActivityFeed).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			expect.objectContaining({ limit: 200 })
 		);
-
-		const activities = (result.result as { activities: { created_at: string }[] }).activities;
-		// Should be sorted by date descending (most recent first)
-		for (let i = 1; i < activities.length; i++) {
-			const prevDate = new Date(activities[i - 1].created_at).getTime();
-			const currDate = new Date(activities[i].created_at).getTime();
-			expect(prevDate).toBeGreaterThanOrEqual(currDate);
-		}
 	});
 
-	it('should filter by created_by', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getActivityFeed.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		await getActivityFeed(
-			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				created_by: 'agent',
-			},
-			ctx
-		);
-
-		expect(supabase.eq).toHaveBeenCalledWith('created_by', 'agent');
-	});
-
-	it('should filter by since parameter', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await getActivityFeed(
-			{
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				since: '2025-01-14T00:00:00Z',
-			},
-			ctx
-		);
-
-		expect(supabase.gt).toHaveBeenCalledWith('created_at', '2025-01-14T00:00:00Z');
+		await expect(
+			getActivityFeed(
+				{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+				ctx
+			)
+		).rejects.toThrow('Failed to fetch activity feed: Query failed');
 	});
 });

package/src/handlers/progress.ts

@@ -4,10 +4,13 @@
  * Handles progress logging and activity feed:
  * - log_progress
  * - get_activity_feed
+ *
+ * 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 logProgress: Handler = async (args, ctx) => {
 	const { project_id, task_id, summary, details } = args as {
@@ -17,166 +20,50 @@ export const logProgress: Handler = async (args, ctx) => {
 		details?: string;
 	};
 
-	const { supabase, session } = ctx;
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+	validateRequired(summary, 'summary');
+
+	const { session } = ctx;
+	const apiClient = getApiClient();
 
-	const { error } = await supabase
-		.from('progress_logs')
-		.insert({
-			project_id,
-			task_id: task_id || null,
-			summary,
-			details: details || null,
-			created_by: 'agent',
-			created_by_session_id: session.currentSessionId,
-		});
+	const response = await apiClient.logProgress(project_id, {
+		summary,
+		details,
+		task_id,
+		session_id: session.currentSessionId || undefined
+	});
 
-	if (error) throw new Error(`Failed to log progress: ${error.message}`);
+	if (!response.ok) {
+		throw new Error(`Failed to log progress: ${response.error}`);
+	}
 
-	return { result: { success: true } };
+	return { result: { success: true, progress_id: response.data?.progress_id } };
 };
 
 export const getActivityFeed: Handler = async (args, ctx) => {
-	const { project_id, types, created_by, since, limit = 50 } = args as {
+	const { project_id, limit = 50, since } = args as {
 		project_id: string;
-		types?: ('task' | 'progress' | 'blocker' | 'decision')[];
-		created_by?: 'agent' | 'user';
-		since?: string;
 		limit?: number;
+		since?: string;
 	};
 
 	validateRequired(project_id, 'project_id');
 	validateUUID(project_id, 'project_id');
 
-	const { supabase } = ctx;
+	const apiClient = getApiClient();
 	const effectiveLimit = Math.min(limit, 200);
-	const includeTypes = types || ['task', 'progress', 'blocker', 'decision'];
-	// Fetch slightly more per type to account for interleaving, but not full limit
-	const perTypeLimit = Math.min(Math.ceil(effectiveLimit / includeTypes.length) * 2, effectiveLimit);
-
-	interface ActivityItem {
-		type: string;
-		id: string;
-		title?: string;
-		summary?: string;
-		description?: string;
-		status?: string;
-		created_by: string;
-		created_at: string;
-	}
-
-	const activities: ActivityItem[] = [];
-
-	// Fetch tasks if included
-	if (includeTypes.includes('task')) {
-		let query = supabase
-			.from('tasks')
-			.select('id, title, status, created_by, created_at, completed_at')
-			.eq('project_id', project_id)
-			.order('created_at', { ascending: false })
-			.limit(perTypeLimit);
-
-		if (created_by) query = query.eq('created_by', created_by);
-		if (since) query = query.gt('created_at', since);
 
-		const { data: tasks } = await query;
-		if (tasks) {
-			for (const task of tasks) {
-				activities.push({
-					type: 'task',
-					id: task.id,
-					title: task.title,
-					status: task.status,
-					created_by: task.created_by,
-					created_at: task.created_at,
-				});
-			}
-		}
-	}
-
-	// Fetch progress logs if included
-	if (includeTypes.includes('progress')) {
-		let query = supabase
-			.from('progress_logs')
-			.select('id, summary, created_by, created_at')
-			.eq('project_id', project_id)
-			.order('created_at', { ascending: false })
-			.limit(perTypeLimit);
-
-		if (created_by) query = query.eq('created_by', created_by);
-		if (since) query = query.gt('created_at', since);
-
-		const { data: logs } = await query;
-		if (logs) {
-			for (const log of logs) {
-				activities.push({
-					type: 'progress',
-					id: log.id,
-					summary: log.summary,
-					created_by: log.created_by,
-					created_at: log.created_at,
-				});
-			}
-		}
-	}
-
-	// Fetch blockers if included
-	if (includeTypes.includes('blocker')) {
-		let query = supabase
-			.from('blockers')
-			.select('id, description, status, created_by, created_at')
-			.eq('project_id', project_id)
-			.order('created_at', { ascending: false })
-			.limit(perTypeLimit);
+	const response = await apiClient.getActivityFeed(project_id, {
+		limit: effectiveLimit,
+		since
+	});
 
-		if (created_by) query = query.eq('created_by', created_by);
-		if (since) query = query.gt('created_at', since);
-
-		const { data: blockers } = await query;
-		if (blockers) {
-			for (const blocker of blockers) {
-				activities.push({
-					type: 'blocker',
-					id: blocker.id,
-					description: blocker.description,
-					status: blocker.status,
-					created_by: blocker.created_by,
-					created_at: blocker.created_at,
-				});
-			}
-		}
-	}
-
-	// Fetch decisions if included
-	if (includeTypes.includes('decision')) {
-		let query = supabase
-			.from('decisions')
-			.select('id, title, created_by, created_at')
-			.eq('project_id', project_id)
-			.order('created_at', { ascending: false })
-			.limit(perTypeLimit);
-
-		if (created_by) query = query.eq('created_by', created_by);
-		if (since) query = query.gt('created_at', since);
-
-		const { data: decisions } = await query;
-		if (decisions) {
-			for (const decision of decisions) {
-				activities.push({
-					type: 'decision',
-					id: decision.id,
-					title: decision.title,
-					created_by: decision.created_by,
-					created_at: decision.created_at,
-				});
-			}
-		}
+	if (!response.ok) {
+		throw new Error(`Failed to fetch activity feed: ${response.error}`);
 	}
 
-	// Sort by created_at descending and limit
-	activities.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-	const limitedActivities = activities.slice(0, effectiveLimit);
-
-	return { result: { activities: limitedActivities } };
+	return { result: { activities: response.data?.activities || [] } };
 };
 
 /**