@vibescope/mcp-server 0.0.1

package/src/handlers/progress.test.ts

@@ -0,0 +1,369 @@
+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(),
+	};
+}
+
+// ============================================================================
+// logProgress Tests
+// ============================================================================
+
+describe('logProgress', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should log progress successfully', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await logProgress(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Completed initial setup',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+	});
+
+	it('should log progress with task_id and details', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await logProgress(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				task_id: '456e4567-e89b-12d3-a456-426614174000',
+				summary: 'Working on feature',
+				details: 'Added the main component and started styling',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				task_id: '456e4567-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',
+			})
+		);
+	});
+
+	it('should include session_id in insert', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await logProgress(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Progress update',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				created_by: 'agent',
+				created_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should query progress_logs table', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await logProgress(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Progress',
+			},
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('progress_logs');
+	});
+
+	it('should throw error when insert fails', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: { message: 'Insert failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logProgress({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				summary: 'Progress',
+			}, ctx)
+		).rejects.toThrow('Failed to log progress: Insert failed');
+	});
+});
+
+// ============================================================================
+// getActivityFeed Tests
+// ============================================================================
+
+describe('getActivityFeed', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getActivityFeed({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getActivityFeed({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty activities when no data', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivityFeed(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			activities: [],
+		});
+	});
+
+	it('should query all activity types by default', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		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 },
+		});
+		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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getActivityFeed(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 10,
+			},
+			ctx
+		);
+
+		expect(supabase.limit).toHaveBeenCalled();
+	});
+
+	it('should cap limit at 200', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getActivityFeed(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 500,
+			},
+			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
+		);
+
+		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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		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');
+	});
+});

package/src/handlers/progress.ts

@@ -0,0 +1,188 @@
+/**
+ * Progress Handlers
+ *
+ * Handles progress logging and activity feed:
+ * - log_progress
+ * - get_activity_feed
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+import { validateRequired, validateUUID } from '../validators.js';
+
+export const logProgress: Handler = async (args, ctx) => {
+	const { project_id, task_id, summary, details } = args as {
+		project_id: string;
+		task_id?: string;
+		summary: string;
+		details?: string;
+	};
+
+	const { supabase, session } = ctx;
+
+	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,
+		});
+
+	if (error) throw new Error(`Failed to log progress: ${error.message}`);
+
+	return { result: { success: true } };
+};
+
+export const getActivityFeed: Handler = async (args, ctx) => {
+	const { project_id, types, created_by, since, limit = 50 } = args as {
+		project_id: string;
+		types?: ('task' | 'progress' | 'blocker' | 'decision')[];
+		created_by?: 'agent' | 'user';
+		since?: string;
+		limit?: number;
+	};
+
+	validateRequired(project_id, 'project_id');
+	validateUUID(project_id, 'project_id');
+
+	const { supabase } = ctx;
+	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);
+
+		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,
+				});
+			}
+		}
+	}
+
+	// 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 } };
+};
+
+/**
+ * Progress handlers registry
+ */
+export const progressHandlers: HandlerRegistry = {
+	log_progress: logProgress,
+	get_activity_feed: getActivityFeed,
+};