@vibescope/mcp-server 0.0.1 → 0.1.0

package/src/handlers/ideas.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import {
 	addIdea,
 	updateIdea,
@@ -7,18 +7,18 @@ import {
 	convertIdeaToTask,
 } from './ideas.js';
 import { ValidationError } from '../validators.js';
-import { createMockSupabase, createMockContext } from './__test-utils__.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
 
 // ============================================================================
 // addIdea Tests
 // ============================================================================
 
 describe('addIdea', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {});
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addIdea({ title: 'New Feature' }, ctx)
@@ -26,8 +26,7 @@ describe('addIdea', () => {
 	});
 
 	it('should throw error for invalid project_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addIdea({ project_id: 'invalid', title: 'New Feature' }, ctx)
@@ -35,8 +34,7 @@ describe('addIdea', () => {
 	});
 
 	it('should throw error for missing title', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addIdea({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
@@ -44,10 +42,11 @@ describe('addIdea', () => {
 	});
 
 	it('should add idea successfully', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'idea-1' }, error: null },
+		mockApiClient.addIdea.mockResolvedValue({
+			ok: true,
+			data: { idea_id: 'idea-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await addIdea(
 			{
@@ -64,11 +63,12 @@ describe('addIdea', () => {
 		});
 	});
 
-	it('should insert with default status "raw"', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'idea-1' }, error: null },
+	it('should call API client with default status "raw"', async () => {
+		mockApiClient.addIdea.mockResolvedValue({
+			ok: true,
+			data: { idea_id: 'idea-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await addIdea(
 			{
@@ -78,18 +78,23 @@ describe('addIdea', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				status: 'raw',
-			})
+		expect(mockApiClient.addIdea).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
+				title: 'New Feature',
+				description: undefined,
+				status: undefined, // Default status applied server-side
+			},
+			'session-123'
 		);
 	});
 
-	it('should insert with custom status', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'idea-1' }, error: null },
+	it('should call API client with custom status', async () => {
+		mockApiClient.addIdea.mockResolvedValue({
+			ok: true,
+			data: { idea_id: 'idea-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await addIdea(
 			{
@@ -100,18 +105,23 @@ describe('addIdea', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.addIdea).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
+				title: 'New Feature',
+				description: undefined,
 				status: 'exploring',
-			})
+			},
+			'session-123'
 		);
 	});
 
-	it('should include session_id in insert', async () => {
-		const supabase = createMockSupabase({
-			insertResult: { data: { id: 'idea-1' }, error: null },
+	it('should include session_id in API call', async () => {
+		mockApiClient.addIdea.mockResolvedValue({
+			ok: true,
+			data: { idea_id: 'idea-1' },
 		});
-		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+		const ctx = createMockContext({ sessionId: 'my-session' });
 
 		await addIdea(
 			{
@@ -121,19 +131,19 @@ describe('addIdea', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
-				created_by: 'agent',
-				created_by_session_id: 'my-session',
-			})
+		expect(mockApiClient.addIdea).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.addIdea.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			addIdea({
@@ -149,41 +159,28 @@ describe('addIdea', () => {
 // ============================================================================
 
 describe('updateIdea', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {});
 
 	it('should throw error for missing idea_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(updateIdea({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid idea_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			updateIdea({ idea_id: 'invalid' }, ctx)
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when idea not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			updateIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Idea not found');
-	});
-
 	it('should update idea title', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'raw' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.updateIdea.mockResolvedValue({
+			ok: true,
+			data: { idea: { id: 'idea-1', title: 'Updated Title' } },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await updateIdea(
 			{
@@ -197,20 +194,14 @@ describe('updateIdea', () => {
 			success: true,
 			idea_id: '123e4567-e89b-12d3-a456-426614174000',
 		});
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				title: 'Updated Title',
-				updated_at: expect.any(String),
-			})
-		);
 	});
 
-	it('should set planned_at when transitioning to planned status', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'exploring' }, error: null },
-			updateResult: { data: null, error: null },
+	it('should call API client with status update', async () => {
+		mockApiClient.updateIdea.mockResolvedValue({
+			ok: true,
+			data: { idea: { id: 'idea-1', status: 'planned' } },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await updateIdea(
 			{
@@ -220,43 +211,23 @@ describe('updateIdea', () => {
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
-				status: 'planned',
-				planned_at: expect.any(String),
-			})
-		);
-	});
-
-	it('should not set planned_at when already in planned status', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'planned' }, error: null },
-			updateResult: { data: null, error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await updateIdea(
+		expect(mockApiClient.updateIdea).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
 			{
-				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: undefined,
+				description: undefined,
 				status: 'planned',
-			},
-			ctx
-		);
-
-		// Should NOT have planned_at since it's already planned
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.not.objectContaining({
-				planned_at: expect.any(String),
-			})
+				doc_url: undefined,
+			}
 		);
 	});
 
 	it('should update doc_url', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'exploring' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.updateIdea.mockResolvedValue({
+			ok: true,
+			data: { idea: { id: 'idea-1' } },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await updateIdea(
 			{
@@ -266,27 +237,23 @@ describe('updateIdea', () => {
 			ctx
 		);
 
-		expect(supabase.update).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.updateIdea).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
+				title: undefined,
+				description: undefined,
+				status: undefined,
 				doc_url: 'https://docs.example.com/feature',
-			})
+			}
 		);
 	});
 
-	it('should throw error when update fails', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: { status: 'raw' }, error: null },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.updateIdea.mockResolvedValue({
+			ok: false,
+			error: 'Idea not found',
 		});
-		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']>);
+		const ctx = createMockContext();
 
 		await expect(
 			updateIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000', title: 'New' }, ctx)
@@ -299,18 +266,16 @@ describe('updateIdea', () => {
 // ============================================================================
 
 describe('getIdeas', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {});
 
 	it('should throw error for missing project_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(getIdeas({}, 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(
 			getIdeas({ project_id: 'invalid' }, ctx)
@@ -318,17 +283,11 @@ describe('getIdeas', () => {
 	});
 
 	it('should return empty list when no ideas', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+		mockApiClient.getIdeas.mockResolvedValue({
+			ok: true,
+			data: { ideas: [] },
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override to return array result
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: [], error: null }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		const result = await getIdeas(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -344,17 +303,11 @@ describe('getIdeas', () => {
 			{ id: 'i2', title: 'Idea 2', description: 'Some desc', status: 'exploring', doc_url: null },
 		];
 
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdeas, error: null },
+		mockApiClient.getIdeas.mockResolvedValue({
+			ok: true,
+			data: { ideas: mockIdeas },
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override to return array result
-		vi.mocked(supabase.from('').select).mockReturnValue({
-			...supabase,
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: mockIdeas, error: null }).then(resolve),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		const result = await getIdeas(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -364,58 +317,58 @@ describe('getIdeas', () => {
 		expect((result.result as { ideas: unknown[] }).ideas).toHaveLength(2);
 	});
 
-	it('should filter by status when provided', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass status filter to API', async () => {
+		mockApiClient.getIdeas.mockResolvedValue({
+			ok: true,
+			data: { ideas: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getIdeas(
 			{ project_id: '123e4567-e89b-12d3-a456-426614174000', status: 'planned' },
 			ctx
 		);
 
-		expect(supabase.eq).toHaveBeenCalledWith('status', 'planned');
-	});
-
-	it('should query ideas table', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
-		});
-		const ctx = createMockContext(supabase);
-
-		await getIdeas(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
-			ctx
+		expect(mockApiClient.getIdeas).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
+				status: 'planned',
+				limit: 50,
+				offset: 0,
+				search_query: undefined,
+			}
 		);
-
-		expect(supabase.from).toHaveBeenCalledWith('ideas');
 	});
 
-	it('should order by created_at descending', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: [], error: null },
+	it('should pass limit and offset to API', async () => {
+		mockApiClient.getIdeas.mockResolvedValue({
+			ok: true,
+			data: { ideas: [] },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await getIdeas(
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000', limit: 10, offset: 5 },
 			ctx
 		);
 
-		expect(supabase.order).toHaveBeenCalledWith('created_at', { ascending: false });
+		expect(mockApiClient.getIdeas).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			{
+				status: undefined,
+				limit: 10,
+				offset: 5,
+				search_query: undefined,
+			}
+		);
 	});
 
-	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']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.getIdeas.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			getIdeas({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
@@ -428,18 +381,16 @@ describe('getIdeas', () => {
 // ============================================================================
 
 describe('deleteIdea', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {});
 
 	it('should throw error for missing idea_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(deleteIdea({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid idea_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			deleteIdea({ idea_id: 'invalid' }, ctx)
@@ -447,19 +398,11 @@ describe('deleteIdea', () => {
 	});
 
 	it('should delete idea successfully', async () => {
-		const supabase = createMockSupabase({
-			deleteResult: { data: null, error: null },
+		mockApiClient.deleteIdea.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-		const ctx = createMockContext(supabase);
-
-		// Override delete to return success
-		vi.mocked(supabase.from('').delete).mockReturnValue({
-			...supabase,
-			eq: vi.fn().mockReturnValue({
-				then: (resolve: (val: unknown) => void) =>
-					Promise.resolve({ data: null, error: null }).then(resolve),
-			}),
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		const result = await deleteIdea(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -469,42 +412,29 @@ describe('deleteIdea', () => {
 		expect(result.result).toMatchObject({ success: true });
 	});
 
-	it('should call delete on ideas table', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
-
-		const mockEq = vi.fn().mockReturnValue({
-			then: (resolve: (val: unknown) => void) =>
-				Promise.resolve({ data: null, error: null }).then(resolve),
+	it('should call API client deleteIdea', async () => {
+		mockApiClient.deleteIdea.mockResolvedValue({
+			ok: true,
+			data: { success: true },
 		});
-
-		vi.mocked(supabase.from('').delete).mockReturnValue({
-			...supabase,
-			eq: mockEq,
-		} as unknown as ReturnType<SupabaseClient['from']>);
+		const ctx = createMockContext();
 
 		await deleteIdea(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.from).toHaveBeenCalledWith('ideas');
-		expect(supabase.delete).toHaveBeenCalled();
-		expect(mockEq).toHaveBeenCalledWith('id', '123e4567-e89b-12d3-a456-426614174000');
+		expect(mockApiClient.deleteIdea).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']>);
+	it('should throw error when API call fails', async () => {
+		mockApiClient.deleteIdea.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
 
 		await expect(
 			deleteIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
@@ -517,18 +447,16 @@ describe('deleteIdea', () => {
 // ============================================================================
 
 describe('convertIdeaToTask', () => {
-	beforeEach(() => vi.clearAllMocks());
+	beforeEach(() => {});
 
 	it('should throw error for missing idea_id', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(convertIdeaToTask({}, ctx)).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid idea_id UUID', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			convertIdeaToTask({ idea_id: 'invalid' }, ctx)
@@ -536,8 +464,7 @@ describe('convertIdeaToTask', () => {
 	});
 
 	it('should throw error for invalid priority', async () => {
-		const supabase = createMockSupabase();
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			convertIdeaToTask({
@@ -547,32 +474,16 @@ describe('convertIdeaToTask', () => {
 		).rejects.toThrow(ValidationError);
 	});
 
-	it('should throw error when idea not found', async () => {
-		const supabase = createMockSupabase({
-			selectResult: { data: null, error: { message: 'Not found' } },
-		});
-		const ctx = createMockContext(supabase);
-
-		await expect(
-			convertIdeaToTask({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Idea not found');
-	});
-
 	it('should return error when idea already converted', async () => {
-		const supabase = createMockSupabase({
-			selectResult: {
-				data: {
-					id: 'idea-1',
-					project_id: 'proj-1',
-					title: 'My Idea',
-					description: null,
-					status: 'in_development',
-					converted_to_task_id: 'existing-task-id',
-				},
-				error: null,
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: false,
+				error: 'Idea has already been converted to a task',
+				existing_task_id: 'existing-task-id',
 			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await convertIdeaToTask(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -587,21 +498,17 @@ describe('convertIdeaToTask', () => {
 	});
 
 	it('should convert idea to task successfully', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: 'Add dark mode',
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: { id: 'task-1', title: 'Feature Request' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: 'task-1',
+				task_title: 'Feature Request',
+				idea_id: 'idea-1',
+				idea_status: 'in_development',
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await convertIdeaToTask(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -617,50 +524,34 @@ describe('convertIdeaToTask', () => {
 	});
 
 	it('should use default priority of 3', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: null,
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: { id: 'task-1', title: 'Feature Request' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true, task_id: 'task-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await convertIdeaToTask(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'convert_idea_to_task',
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
 				priority: 3,
-			})
+				estimated_minutes: undefined,
+				update_status: true,
+			}
 		);
 	});
 
 	it('should use custom priority when provided', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: null,
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: { id: 'task-1', title: 'Feature Request' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: { success: true, task_id: 'task-1' },
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await convertIdeaToTask(
 			{
@@ -670,29 +561,29 @@ describe('convertIdeaToTask', () => {
 			ctx
 		);
 
-		expect(supabase.insert).toHaveBeenCalledWith(
-			expect.objectContaining({
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'convert_idea_to_task',
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
 				priority: 1,
-			})
+				estimated_minutes: undefined,
+				update_status: true,
+			}
 		);
 	});
 
 	it('should update idea status to in_development by default', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: null,
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: { id: 'task-1', title: 'Feature Request' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: 'task-1',
+				task_title: 'Feature Request',
+				idea_id: 'idea-1',
+				idea_status: 'in_development',
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		const result = await convertIdeaToTask(
 			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
@@ -703,23 +594,19 @@ describe('convertIdeaToTask', () => {
 	});
 
 	it('should not update status when update_status is false', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: null,
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: { id: 'task-1', title: 'Feature Request' }, error: null },
-			updateResult: { data: null, error: null },
+		mockApiClient.proxy.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				task_id: 'task-1',
+				task_title: 'Feature Request',
+				idea_id: 'idea-1',
+				idea_status: 'planned',
+			},
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
-		const result = await convertIdeaToTask(
+		await convertIdeaToTask(
 			{
 				idea_id: '123e4567-e89b-12d3-a456-426614174000',
 				update_status: false,
@@ -727,27 +614,26 @@ describe('convertIdeaToTask', () => {
 			ctx
 		);
 
-		expect((result.result as { idea_status: string }).idea_status).toBe('planned');
+		expect(mockApiClient.proxy).toHaveBeenCalledWith(
+			'convert_idea_to_task',
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				priority: 3,
+				estimated_minutes: undefined,
+				update_status: false,
+			}
+		);
 	});
 
-	it('should throw error when task creation fails', async () => {
-		const mockIdea = {
-			id: 'idea-1',
-			project_id: 'proj-1',
-			title: 'Feature Request',
-			description: null,
-			status: 'planned',
-			converted_to_task_id: null,
-		};
-
-		const supabase = createMockSupabase({
-			selectResult: { data: mockIdea, error: null },
-			insertResult: { data: null, error: { message: 'Insert failed' } },
+	it('should throw error when API call fails', async () => {
+		mockApiClient.proxy.mockResolvedValue({
+			ok: false,
+			error: 'Idea not found',
 		});
-		const ctx = createMockContext(supabase);
+		const ctx = createMockContext();
 
 		await expect(
 			convertIdeaToTask({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to create task');
+		).rejects.toThrow('Failed to convert idea');
 	});
 });