@vibescope/mcp-server 0.0.1

package/src/handlers/ideas.test.ts

@@ -0,0 +1,753 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	addIdea,
+	updateIdea,
+	getIdeas,
+	deleteIdea,
+	convertIdeaToTask,
+} from './ideas.js';
+import { ValidationError } from '../validators.js';
+import { createMockSupabase, createMockContext } from './__test-utils__.js';
+
+// ============================================================================
+// addIdea Tests
+// ============================================================================
+
+describe('addIdea', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addIdea({ title: 'New Feature' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addIdea({ project_id: 'invalid', title: 'New Feature' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addIdea({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should add idea successfully', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'idea-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await addIdea(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Dark Mode Support',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			idea_id: 'idea-1',
+			title: 'Dark Mode Support',
+		});
+	});
+
+	it('should insert with default status "raw"', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'idea-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await addIdea(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'New Feature',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				status: 'raw',
+			})
+		);
+	});
+
+	it('should insert with custom status', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'idea-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await addIdea(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'New Feature',
+				status: 'exploring',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				status: 'exploring',
+			})
+		);
+	});
+
+	it('should include session_id in insert', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: { id: 'idea-1' }, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await addIdea(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'New Feature',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				created_by: 'agent',
+				created_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should throw error when insert fails', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: { message: 'Insert failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			addIdea({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'New Feature',
+			}, ctx)
+		).rejects.toThrow('Failed to add idea');
+	});
+});
+
+// ============================================================================
+// updateIdea Tests
+// ============================================================================
+
+describe('updateIdea', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing idea_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(updateIdea({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid idea_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await updateIdea(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Updated Title',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		await updateIdea(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				status: 'planned',
+			},
+			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(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				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),
+			})
+		);
+	});
+
+	it('should update doc_url', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { status: 'exploring' }, error: null },
+			updateResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await updateIdea(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				doc_url: 'https://docs.example.com/feature',
+			},
+			ctx
+		);
+
+		expect(supabase.update).toHaveBeenCalledWith(
+			expect.objectContaining({
+				doc_url: 'https://docs.example.com/feature',
+			})
+		);
+	});
+
+	it('should throw error when update fails', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: { status: 'raw' }, error: null },
+		});
+		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']>);
+
+		await expect(
+			updateIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000', title: 'New' }, ctx)
+		).rejects.toThrow('Failed to update idea');
+	});
+});
+
+// ============================================================================
+// getIdeas Tests
+// ============================================================================
+
+describe('getIdeas', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getIdeas({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getIdeas({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no ideas', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		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 result = await getIdeas(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ ideas: [] });
+	});
+
+	it('should return ideas list', async () => {
+		const mockIdeas = [
+			{ id: 'i1', title: 'Idea 1', description: null, status: 'raw', doc_url: null },
+			{ id: 'i2', title: 'Idea 2', description: 'Some desc', status: 'exploring', doc_url: null },
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockIdeas, error: null },
+		});
+		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 result = await getIdeas(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { ideas: unknown[] }).ideas).toHaveLength(2);
+	});
+
+	it('should filter by status when provided', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		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(supabase.from).toHaveBeenCalledWith('ideas');
+	});
+
+	it('should order by created_at descending', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getIdeas(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.order).toHaveBeenCalledWith('created_at', { ascending: false });
+	});
+
+	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']>);
+
+		await expect(
+			getIdeas({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to fetch ideas');
+	});
+});
+
+// ============================================================================
+// deleteIdea Tests
+// ============================================================================
+
+describe('deleteIdea', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing idea_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(deleteIdea({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid idea_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			deleteIdea({ idea_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete idea successfully', async () => {
+		const supabase = createMockSupabase({
+			deleteResult: { data: null, error: null },
+		});
+		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 result = await deleteIdea(
+			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		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),
+		});
+
+		vi.mocked(supabase.from('').delete).mockReturnValue({
+			...supabase,
+			eq: mockEq,
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		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');
+	});
+
+	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']>);
+
+		await expect(
+			deleteIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to delete idea');
+	});
+});
+
+// ============================================================================
+// convertIdeaToTask Tests
+// ============================================================================
+
+describe('convertIdeaToTask', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing idea_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(convertIdeaToTask({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid idea_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			convertIdeaToTask({ idea_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid priority', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			convertIdeaToTask({
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				priority: 10, // Invalid
+			}, ctx)
+		).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,
+			},
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await convertIdeaToTask(
+			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: false,
+			error: 'Idea has already been converted to a task',
+			existing_task_id: 'existing-task-id',
+		});
+	});
+
+	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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await convertIdeaToTask(
+			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_id: 'task-1',
+			task_title: 'Feature Request',
+			idea_id: 'idea-1',
+		});
+	});
+
+	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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		await convertIdeaToTask(
+			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				priority: 3,
+			})
+		);
+	});
+
+	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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		await convertIdeaToTask(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				priority: 1,
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				priority: 1,
+			})
+		);
+	});
+
+	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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await convertIdeaToTask(
+			{ idea_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { idea_status: string }).idea_status).toBe('in_development');
+	});
+
+	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 },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await convertIdeaToTask(
+			{
+				idea_id: '123e4567-e89b-12d3-a456-426614174000',
+				update_status: false,
+			},
+			ctx
+		);
+
+		expect((result.result as { idea_status: string }).idea_status).toBe('planned');
+	});
+
+	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' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			convertIdeaToTask({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to create task');
+	});
+});