@vibescope/mcp-server 0.0.1 → 0.2.0

package/src/handlers/session.test.ts

@@ -1,152 +1,28 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { HandlerContext, TokenUsage } from './types.js';
 import {
+	startWorkSession,
 	heartbeat,
 	endWorkSession,
 	getHelp,
 	getTokenUsage,
 } from './session.js';
-
-// ============================================================================
-// Test Utilities
-// ============================================================================
-
-/**
- * Creates a mock Supabase client with chainable methods
- */
-function createMockSupabase(overrides: {
-	selectResult?: { data: unknown; error: unknown };
-	insertResult?: { data: unknown; error: unknown };
-	updateResult?: { 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;
-		}),
-		update: vi.fn(() => {
-			currentOperation = 'update';
-			insertThenSelect = false;
-			return mock;
-		}),
-		delete: vi.fn(() => {
-			currentOperation = 'delete';
-			insertThenSelect = false;
-			return mock;
-		}),
-		eq: vi.fn().mockReturnThis(),
-		neq: vi.fn().mockReturnThis(),
-		in: vi.fn().mockReturnThis(),
-		is: vi.fn().mockReturnThis(),
-		not: vi.fn().mockReturnThis(),
-		or: vi.fn().mockReturnThis(),
-		gte: vi.fn().mockReturnThis(),
-		lt: vi.fn().mockReturnThis(),
-		order: vi.fn().mockReturnThis(),
-		limit: 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);
-			}
-			if (currentOperation === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult);
-			}
-			return Promise.resolve(defaultResult);
-		}),
-		maybeSingle: vi.fn(() => {
-			return Promise.resolve(overrides.selectResult ?? 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 === 'update') {
-				return Promise.resolve(overrides.updateResult ?? defaultResult).then(resolve);
-			}
-			return Promise.resolve(defaultResult).then(resolve);
-		}),
-	};
-
-	return mock as unknown as SupabaseClient;
-}
-
-/**
- * Creates a mock handler context with full session state
- */
-function createMockContext(
-	supabase: SupabaseClient,
-	options: {
-		sessionId?: string | null;
-		tokenUsage?: TokenUsage;
-	} = {}
-): HandlerContext {
-	const defaultTokenUsage: TokenUsage = {
-		callCount: 10,
-		totalTokens: 5000,
-		byTool: {
-			get_tasks: { calls: 3, tokens: 1500 },
-			update_task: { calls: 4, tokens: 2000 },
-			complete_task: { calls: 3, tokens: 1500 },
-		},
-	};
-
-	// Use 'in' check to allow explicit null values for sessionId
-	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
-
-	return {
-		supabase,
-		auth: {
-			userId: 'user-123',
-			apiKeyId: 'api-key-123',
-		},
-		session: {
-			instanceId: 'instance-abc123',
-			currentSessionId: sessionId,
-			currentPersona: 'Wave',
-			tokenUsage: options.tokenUsage ?? defaultTokenUsage,
-		},
-		updateSession: vi.fn(),
-	};
-}
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // heartbeat Tests
 // ============================================================================
 
 describe('heartbeat', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
+	beforeEach(() => vi.clearAllMocks());
 
 	it('should record heartbeat successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
-			updateResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.heartbeat.mockResolvedValue({
+			ok: true,
+			data: { timestamp: '2026-01-14T10:00:00Z' },
 		});
-		const ctx = createMockContext(supabase);
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
 
 		const result = await heartbeat({}, ctx);
 
@@ -155,16 +31,16 @@ describe('heartbeat', () => {
 			session_id: 'session-123',
 		});
 		expect(result.result).toHaveProperty('timestamp');
-		expect(supabase.from).toHaveBeenCalledWith('agent_heartbeats');
-		expect(supabase.insert).toHaveBeenCalled();
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', { current_worktree_path: undefined });
 	});
 
 	it('should use provided session_id over current session', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
-			updateResult: { data: null, error: null },
+		const ctx = createMockContext();
+		mockApiClient.heartbeat.mockResolvedValue({
+			ok: true,
+			data: { timestamp: '2026-01-14T10:00:00Z' },
 		});
-		const ctx = createMockContext(supabase);
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
 
 		const result = await heartbeat({ session_id: 'other-session-456' }, ctx);
 
@@ -172,11 +48,24 @@ describe('heartbeat', () => {
 			success: true,
 			session_id: 'other-session-456',
 		});
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('other-session-456', { current_worktree_path: undefined });
+	});
+
+	it('should pass worktree_path to API', async () => {
+		const ctx = createMockContext();
+		mockApiClient.heartbeat.mockResolvedValue({
+			ok: true,
+			data: { timestamp: '2026-01-14T10:00:00Z' },
+		});
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
+
+		await heartbeat({ current_worktree_path: '../project-task-abc123' }, ctx);
+
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', { current_worktree_path: '../project-task-abc123' });
 	});
 
 	it('should return error when no active session', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, { sessionId: null });
+		const ctx = createMockContext({ sessionId: null });
 
 		const result = await heartbeat({}, ctx);
 
@@ -185,19 +74,31 @@ describe('heartbeat', () => {
 		});
 	});
 
-	it('should update session with token usage', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: null, error: null },
-			updateResult: { data: null, error: null },
+	it('should sync session with token usage', async () => {
+		const ctx = createMockContext({
+			tokenUsage: {
+				callCount: 10,
+				totalTokens: 5000,
+				byTool: {
+					get_tasks: { calls: 3, tokens: 1500 },
+					update_task: { calls: 4, tokens: 2000 },
+					complete_task: { calls: 3, tokens: 1500 },
+				},
+				byModel: {},
+				currentModel: null,
+			},
 		});
-		const ctx = createMockContext(supabase);
+		mockApiClient.heartbeat.mockResolvedValue({
+			ok: true,
+			data: { timestamp: '2026-01-14T10:00:00Z' },
+		});
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
 
 		await heartbeat({}, ctx);
 
-		expect(supabase.from).toHaveBeenCalledWith('agent_sessions');
-		expect(supabase.update).toHaveBeenCalledWith(
+		expect(mockApiClient.syncSession).toHaveBeenCalledWith(
+			'session-123',
 			expect.objectContaining({
-				status: 'active',
 				total_tokens: 5000,
 			})
 		);
@@ -209,13 +110,14 @@ describe('heartbeat', () => {
 // ============================================================================
 
 describe('getHelp', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
+	beforeEach(() => vi.clearAllMocks());
 
 	it('should return help content for valid topic', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.getHelpTopic.mockResolvedValue({
+			ok: true,
+			data: { slug: 'tasks', title: 'Task Workflow', content: '# Task Workflow\nTest content' },
+		});
 
 		const result = await getHelp({ topic: 'tasks' }, ctx);
 
@@ -224,8 +126,11 @@ describe('getHelp', () => {
 	});
 
 	it('should return getting_started help', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.getHelpTopic.mockResolvedValue({
+			ok: true,
+			data: { slug: 'getting_started', title: 'Getting Started', content: '# Getting Started\nTest content' },
+		});
 
 		const result = await getHelp({ topic: 'getting_started' }, ctx);
 
@@ -234,8 +139,12 @@ describe('getHelp', () => {
 	});
 
 	it('should return error for unknown topic', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.getHelpTopic.mockResolvedValue({ ok: true, data: null });
+		mockApiClient.getHelpTopics.mockResolvedValue({
+			ok: true,
+			data: [{ slug: 'tasks', title: 'Tasks' }, { slug: 'getting_started', title: 'Getting Started' }],
+		});
 
 		const result = await getHelp({ topic: 'unknown_topic' }, ctx);
 
@@ -246,8 +155,16 @@ describe('getHelp', () => {
 	});
 
 	it('should list available topics for unknown topic', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
+		mockApiClient.getHelpTopic.mockResolvedValue({ ok: true, data: null });
+		mockApiClient.getHelpTopics.mockResolvedValue({
+			ok: true,
+			data: [
+				{ slug: 'tasks', title: 'Tasks' },
+				{ slug: 'getting_started', title: 'Getting Started' },
+				{ slug: 'validation', title: 'Validation' },
+			],
+		});
 
 		const result = await getHelp({ topic: 'nonexistent' }, ctx);
 
@@ -262,13 +179,10 @@ describe('getHelp', () => {
 // ============================================================================
 
 describe('getTokenUsage', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
+	beforeEach(() => vi.clearAllMocks());
 
 	it('should return token usage stats', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await getTokenUsage({}, ctx);
 
@@ -278,12 +192,13 @@ describe('getTokenUsage', () => {
 	});
 
 	it('should return correct session stats', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, {
+		const ctx = createMockContext({
 			tokenUsage: {
 				callCount: 10,
 				totalTokens: 5000,
 				byTool: {},
+				byModel: {},
+				currentModel: null,
 			},
 		});
 
@@ -296,8 +211,7 @@ describe('getTokenUsage', () => {
 	});
 
 	it('should return top tools sorted by tokens', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, {
+		const ctx = createMockContext({
 			tokenUsage: {
 				callCount: 10,
 				totalTokens: 5000,
@@ -306,6 +220,8 @@ describe('getTokenUsage', () => {
 					tool_b: { calls: 5, tokens: 3000 },
 					tool_c: { calls: 3, tokens: 1000 },
 				},
+				byModel: {},
+				currentModel: null,
 			},
 		});
 
@@ -318,12 +234,13 @@ describe('getTokenUsage', () => {
 	});
 
 	it('should handle zero calls gracefully', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, {
+		const ctx = createMockContext({
 			tokenUsage: {
 				callCount: 0,
 				totalTokens: 0,
 				byTool: {},
+				byModel: {},
+				currentModel: null,
 			},
 		});
 
@@ -336,8 +253,7 @@ describe('getTokenUsage', () => {
 	});
 
 	it('should limit top_tools to 5', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, {
+		const ctx = createMockContext({
 			tokenUsage: {
 				callCount: 20,
 				totalTokens: 10000,
@@ -350,6 +266,8 @@ describe('getTokenUsage', () => {
 					tool_6: { calls: 6, tokens: 600 },
 					tool_7: { calls: 7, tokens: 700 },
 				},
+				byModel: {},
+				currentModel: null,
 			},
 		});
 
@@ -365,13 +283,10 @@ describe('getTokenUsage', () => {
 // ============================================================================
 
 describe('endWorkSession', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
+	beforeEach(() => vi.clearAllMocks());
 
 	it('should handle no active session gracefully', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase, { sessionId: null });
+		const ctx = createMockContext({ sessionId: null });
 
 		const result = await endWorkSession({}, ctx);
 
@@ -382,35 +297,40 @@ describe('endWorkSession', () => {
 	});
 
 	it('should use provided session_id over current session', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					project_id: 'project-123',
+		const ctx = createMockContext();
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
+		mockApiClient.endSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_summary: {
 					agent_name: 'Wave',
-					started_at: new Date().toISOString()
+					tasks_completed_this_session: 3,
+					tasks_awaiting_validation: 1,
+					tasks_released: 0,
 				},
-				error: null
 			},
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await endWorkSession({ session_id: 'other-session-456' }, ctx);
 
 		expect(result.result).toHaveProperty('ended_session_id', 'other-session-456');
+		expect(mockApiClient.endSession).toHaveBeenCalledWith('other-session-456');
 	});
 
 	it('should call updateSession to clear current session', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					project_id: 'project-123',
+		const ctx = createMockContext();
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
+		mockApiClient.endSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_summary: {
 					agent_name: 'Wave',
-					started_at: new Date().toISOString()
+					tasks_completed_this_session: 0,
+					tasks_awaiting_validation: 0,
+					tasks_released: 0,
 				},
-				error: null
 			},
 		});
-		const ctx = createMockContext(supabase);
 
 		await endWorkSession({}, ctx);
 
@@ -418,17 +338,19 @@ describe('endWorkSession', () => {
 	});
 
 	it('should return session summary', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					project_id: 'project-123',
+		const ctx = createMockContext();
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
+		mockApiClient.endSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_summary: {
 					agent_name: 'Wave',
-					started_at: new Date().toISOString()
+					tasks_completed_this_session: 2,
+					tasks_awaiting_validation: 1,
+					tasks_released: 0,
 				},
-				error: null
 			},
 		});
-		const ctx = createMockContext(supabase);
 
 		const result = await endWorkSession({}, ctx);
 
@@ -439,17 +361,19 @@ describe('endWorkSession', () => {
 	});
 
 	it('should not call updateSession when ending a different session', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					project_id: 'project-123',
+		const ctx = createMockContext({ sessionId: 'session-123' });
+		mockApiClient.syncSession.mockResolvedValue({ ok: true });
+		mockApiClient.endSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_summary: {
 					agent_name: 'Wave',
-					started_at: new Date().toISOString()
+					tasks_completed_this_session: 0,
+					tasks_awaiting_validation: 0,
+					tasks_released: 0,
 				},
-				error: null
 			},
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'session-123' });
 
 		await endWorkSession({ session_id: 'different-session' }, ctx);
 
@@ -457,3 +381,149 @@ describe('endWorkSession', () => {
 		expect(ctx.updateSession).not.toHaveBeenCalledWith({ currentSessionId: null });
 	});
 });
+
+// ============================================================================
+// startWorkSession Tests
+// ============================================================================
+
+describe('startWorkSession', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should return error when project_id and git_url are both missing', async () => {
+		const ctx = createMockContext({ sessionId: null });
+
+		const result = await startWorkSession({}, ctx);
+
+		expect(result.result).toMatchObject({
+			error: 'Please provide project_id or git_url to start a session',
+		});
+	});
+
+	it('should return project_not_found when no project matches', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: false,
+				project_not_found: true,
+				message: 'No project found',
+				suggestion: {
+					action: 'create_project',
+					example: 'create_project(name: "repo")',
+					note: 'After creating the project, call start_work_session again.',
+				},
+			},
+		});
+
+		const result = await startWorkSession({ git_url: 'https://github.com/test/repo' }, ctx);
+
+		expect(result.result).toMatchObject({
+			session_started: false,
+			project_not_found: true,
+		});
+		expect(result.result).toHaveProperty('suggestion');
+	});
+
+	it('should reuse existing persona when session already has one', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'existing-session-123',
+				persona: 'Pixel',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+			},
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toMatchObject({
+			session_started: true,
+			persona: 'Pixel',
+		});
+	});
+
+	it('should call updateSession with session ID and persona', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'new-session-123',
+				persona: 'Wave',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+			},
+		});
+
+		await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(ctx.updateSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				currentSessionId: 'new-session-123',
+				currentPersona: 'Wave',
+			})
+		);
+	});
+
+	it('should return lite mode response by default', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'new-session-123',
+				persona: 'Wave',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+				directive: 'ACTION_REQUIRED: Start working immediately.',
+			},
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toMatchObject({
+			session_started: true,
+		});
+		expect(result.result).toHaveProperty('project');
+		expect(result.result).toHaveProperty('directive');
+	});
+
+	it('should return error when API call fails', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: false,
+			error: 'Internal server error',
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toMatchObject({
+			error: 'Internal server error',
+		});
+	});
+
+	it('should include next_task when available', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'new-session-123',
+				persona: 'Wave',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+				next_task: { id: 'task-1', title: 'Fix bug', priority: 1 },
+			},
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toHaveProperty('next_task');
+		expect((result.result as { next_task: { id: string } }).next_task.id).toBe('task-1');
+	});
+});