@vibescope/mcp-server 0.5.0 → 0.5.2

package/src/handlers/findings.test.ts

@@ -1,633 +1,633 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	addFinding,
-	getFindings,
-	getFindingsStats,
-	updateFinding,
-	deleteFinding,
-	queryKnowledgeBase,
-} from './findings.js';
-import { ValidationError } from '../validators.js';
-import { createMockContext } from './__test-utils__.js';
-import { mockApiClient } from './__test-setup__.js';
-
-const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
-const VALID_UUID_2 = '223e4567-e89b-12d3-a456-426614174001';
-
-// ============================================================================
-// addFinding Tests
-// ============================================================================
-
-describe('addFinding', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(addFinding({ title: 'Test Finding' }, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addFinding({ project_id: 'invalid', title: 'Test' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for missing title', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addFinding({ project_id: VALID_UUID }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid related_task_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addFinding({ project_id: VALID_UUID, title: 'Test', related_task_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should create finding with required fields', async () => {
-		mockApiClient.addFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true, finding_id: 'finding-1', title: 'Performance issue' },
-		});
-		const ctx = createMockContext();
-
-		const result = await addFinding(
-			{ project_id: VALID_UUID, title: 'Performance issue' },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-			finding_id: 'finding-1',
-			title: 'Performance issue',
-		});
-	});
-
-	it('should call API client with all parameters', async () => {
-		mockApiClient.addFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true, finding_id: 'finding-2' },
-		});
-		const ctx = createMockContext({ sessionId: 'my-session' });
-
-		await addFinding(
-			{
-				project_id: VALID_UUID,
-				title: 'SQL Injection vulnerability',
-				description: 'User input not sanitized',
-				category: 'security',
-				severity: 'critical',
-				file_path: 'src/api/users.ts',
-				line_number: 42,
-				related_task_id: VALID_UUID_2,
-			},
-			ctx
-		);
-
-		expect(mockApiClient.addFinding).toHaveBeenCalledWith(
-			VALID_UUID,
-			{
-				title: 'SQL Injection vulnerability',
-				description: 'User input not sanitized',
-				category: 'security',
-				severity: 'critical',
-				file_path: 'src/api/users.ts',
-				line_number: 42,
-				related_task_id: VALID_UUID_2,
-			},
-			'my-session'
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.addFinding.mockResolvedValue({
-			ok: false,
-			error: 'Insert failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await addFinding({ project_id: VALID_UUID, title: 'Test' }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Insert failed' });
-	});
-});
-
-// ============================================================================
-// getFindings Tests
-// ============================================================================
-
-describe('getFindings', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(getFindings({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getFindings({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return findings for project', async () => {
-		const mockFindings = [
-			{ id: 'f1', title: 'Finding 1', category: 'security', severity: 'high', status: 'open', file_path: null, created_at: '2026-01-14' },
-			{ id: 'f2', title: 'Finding 2', category: 'performance', severity: 'medium', status: 'addressed', file_path: 'src/app.ts', created_at: '2026-01-13' },
-		];
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: mockFindings },
-		});
-		const ctx = createMockContext();
-
-		const result = await getFindings({ project_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({ findings: mockFindings });
-	});
-
-	it('should pass filters to API client', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await getFindings({
-			project_id: VALID_UUID,
-			category: 'security',
-			severity: 'critical',
-			status: 'open',
-			limit: 10
-		}, ctx);
-
-		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				category: 'security',
-				severity: 'critical',
-				status: 'open',
-				limit: 10,
-			})
-		);
-	});
-
-	it('should pass summary_only parameter to API client', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: [], total_count: 0, has_more: false },
-		});
-		const ctx = createMockContext();
-
-		await getFindings({
-			project_id: VALID_UUID,
-			summary_only: true
-		}, ctx);
-
-		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				summary_only: true,
-			})
-		);
-	});
-
-	it('should pass search_query parameter to API client', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: [], total_count: 0, has_more: false },
-		});
-		const ctx = createMockContext();
-
-		await getFindings({
-			project_id: VALID_UUID,
-			search_query: 'security'
-		}, ctx);
-
-		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				search_query: 'security',
-			})
-		);
-	});
-
-	it('should pass offset parameter to API client', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: [], total_count: 100, has_more: true },
-		});
-		const ctx = createMockContext();
-
-		await getFindings({
-			project_id: VALID_UUID,
-			offset: 50,
-			limit: 25
-		}, ctx);
-
-		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				offset: 50,
-				limit: 25,
-			})
-		);
-	});
-
-	it('should use default limit of 10 and summary_only true', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await getFindings({ project_id: VALID_UUID }, ctx);
-
-		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({ limit: 10, summary_only: true })
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.getFindings.mockResolvedValue({
-			ok: false,
-			error: 'Query failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await getFindings({ project_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Query failed' });
-	});
-});
-
-// ============================================================================
-// updateFinding Tests
-// ============================================================================
-
-describe('updateFinding', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing finding_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(updateFinding({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid finding_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			updateFinding({ finding_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should update title', async () => {
-		mockApiClient.updateFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true, finding_id: VALID_UUID },
-		});
-		const ctx = createMockContext();
-
-		const result = await updateFinding(
-			{ finding_id: VALID_UUID, title: 'Updated Title' },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({ success: true, finding_id: VALID_UUID });
-	});
-
-	it('should call API client with all update fields', async () => {
-		mockApiClient.updateFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-		const ctx = createMockContext();
-
-		await updateFinding(
-			{
-				finding_id: VALID_UUID,
-				title: 'New Title',
-				description: 'New description',
-				severity: 'high',
-				status: 'addressed',
-				resolution_note: 'Fixed by sanitizing input'
-			},
-			ctx
-		);
-
-		expect(mockApiClient.updateFinding).toHaveBeenCalledWith(
-			VALID_UUID,
-			{
-				title: 'New Title',
-				description: 'New description',
-				severity: 'high',
-				status: 'addressed',
-				resolution_note: 'Fixed by sanitizing input',
-			}
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.updateFinding.mockResolvedValue({
-			ok: false,
-			error: 'Update failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await updateFinding({ finding_id: VALID_UUID, title: 'Test' }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Update failed' });
-	});
-});
-
-// ============================================================================
-// deleteFinding Tests
-// ============================================================================
-
-describe('deleteFinding', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing finding_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(deleteFinding({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid finding_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			deleteFinding({ finding_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should delete finding successfully', async () => {
-		mockApiClient.deleteFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-		const ctx = createMockContext();
-
-		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({ success: true });
-	});
-
-	it('should call API client deleteFinding', async () => {
-		mockApiClient.deleteFinding.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-		const ctx = createMockContext();
-
-		await deleteFinding({ finding_id: VALID_UUID }, ctx);
-
-		expect(mockApiClient.deleteFinding).toHaveBeenCalledWith(VALID_UUID);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.deleteFinding.mockResolvedValue({
-			ok: false,
-			error: 'Delete failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Delete failed' });
-	});
-});
-
-// ============================================================================
-// getFindingsStats Tests
-// ============================================================================
-
-describe('getFindingsStats', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(getFindingsStats({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getFindingsStats({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return findings stats for project', async () => {
-		const mockStats = {
-			total: 10,
-			by_status: { open: 5, addressed: 3, dismissed: 2 },
-			by_severity: { critical: 1, high: 3, medium: 4, low: 2 },
-			by_category: { security: 3, performance: 4, code_quality: 3 },
-		};
-		mockApiClient.getFindingsStats.mockResolvedValue({
-			ok: true,
-			data: mockStats,
-		});
-		const ctx = createMockContext();
-
-		const result = await getFindingsStats({ project_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject(mockStats);
-	});
-
-	it('should call API client getFindingsStats with project_id', async () => {
-		mockApiClient.getFindingsStats.mockResolvedValue({
-			ok: true,
-			data: { total: 0, by_status: {}, by_severity: {}, by_category: {} },
-		});
-		const ctx = createMockContext();
-
-		await getFindingsStats({ project_id: VALID_UUID }, ctx);
-
-		expect(mockApiClient.getFindingsStats).toHaveBeenCalledWith(VALID_UUID);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.getFindingsStats.mockResolvedValue({
-			ok: false,
-			error: 'Query failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await getFindingsStats({ project_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Query failed' });
-	});
-});
-
-// ============================================================================
-// queryKnowledgeBase Tests
-// ============================================================================
-
-describe('queryKnowledgeBase', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(queryKnowledgeBase({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			queryKnowledgeBase({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid scope value', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			queryKnowledgeBase({ project_id: VALID_UUID, scope: 'invalid_scope' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should query with default parameters', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: {
-				findings: [],
-				decisions: [],
-				completed_tasks: [],
-				resolved_blockers: [],
-			},
-		});
-		const ctx = createMockContext();
-
-		const result = await queryKnowledgeBase({ project_id: VALID_UUID }, ctx);
-
-		expect(result.result).toMatchObject({
-			findings: [],
-			decisions: [],
-		});
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				scope: 'summary',
-				limit: 5,
-			})
-		);
-	});
-
-	it('should pass scope parameter', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await queryKnowledgeBase({ project_id: VALID_UUID, scope: 'detailed' }, ctx);
-
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({ scope: 'detailed' })
-		);
-	});
-
-	it('should pass categories filter', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: { findings: [], decisions: [] },
-		});
-		const ctx = createMockContext();
-
-		await queryKnowledgeBase({
-			project_id: VALID_UUID,
-			categories: ['findings', 'decisions']
-		}, ctx);
-
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({
-				categories: ['findings', 'decisions']
-			})
-		);
-	});
-
-	it('should cap limit at 20', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await queryKnowledgeBase({ project_id: VALID_UUID, limit: 100 }, ctx);
-
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({ limit: 20 })
-		);
-	});
-
-	it('should enforce minimum limit of 1', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await queryKnowledgeBase({ project_id: VALID_UUID, limit: -5 }, ctx);
-
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({ limit: 1 })
-		);
-	});
-
-	it('should pass search_query', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: true,
-			data: { findings: [] },
-		});
-		const ctx = createMockContext();
-
-		await queryKnowledgeBase({
-			project_id: VALID_UUID,
-			search_query: 'security'
-		}, ctx);
-
-		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
-			VALID_UUID,
-			expect.objectContaining({ search_query: 'security' })
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.queryKnowledgeBase.mockResolvedValue({
-			ok: false,
-			error: 'Query failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await queryKnowledgeBase({ project_id: VALID_UUID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Query failed' });
-	});
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	addFinding,
+	getFindings,
+	getFindingsStats,
+	updateFinding,
+	deleteFinding,
+	queryKnowledgeBase,
+} from './findings.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+const VALID_UUID = '123e4567-e89b-12d3-a456-426614174000';
+const VALID_UUID_2 = '223e4567-e89b-12d3-a456-426614174001';
+
+// ============================================================================
+// addFinding Tests
+// ============================================================================
+
+describe('addFinding', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(addFinding({ title: 'Test Finding' }, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addFinding({ project_id: 'invalid', title: 'Test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addFinding({ project_id: VALID_UUID }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid related_task_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addFinding({ project_id: VALID_UUID, title: 'Test', related_task_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should create finding with required fields', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: 'finding-1', title: 'Performance issue' },
+		});
+		const ctx = createMockContext();
+
+		const result = await addFinding(
+			{ project_id: VALID_UUID, title: 'Performance issue' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			finding_id: 'finding-1',
+			title: 'Performance issue',
+		});
+	});
+
+	it('should call API client with all parameters', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: 'finding-2' },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await addFinding(
+			{
+				project_id: VALID_UUID,
+				title: 'SQL Injection vulnerability',
+				description: 'User input not sanitized',
+				category: 'security',
+				severity: 'critical',
+				file_path: 'src/api/users.ts',
+				line_number: 42,
+				related_task_id: VALID_UUID_2,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addFinding).toHaveBeenCalledWith(
+			VALID_UUID,
+			{
+				title: 'SQL Injection vulnerability',
+				description: 'User input not sanitized',
+				category: 'security',
+				severity: 'critical',
+				file_path: 'src/api/users.ts',
+				line_number: 42,
+				related_task_id: VALID_UUID_2,
+			},
+			'my-session'
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.addFinding.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await addFinding({ project_id: VALID_UUID, title: 'Test' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Insert failed' });
+	});
+});
+
+// ============================================================================
+// getFindings Tests
+// ============================================================================
+
+describe('getFindings', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getFindings({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getFindings({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return findings for project', async () => {
+		const mockFindings = [
+			{ id: 'f1', title: 'Finding 1', category: 'security', severity: 'high', status: 'open', file_path: null, created_at: '2026-01-14' },
+			{ id: 'f2', title: 'Finding 2', category: 'performance', severity: 'medium', status: 'addressed', file_path: 'src/app.ts', created_at: '2026-01-13' },
+		];
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: mockFindings },
+		});
+		const ctx = createMockContext();
+
+		const result = await getFindings({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ findings: mockFindings });
+	});
+
+	it('should pass filters to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await getFindings({
+			project_id: VALID_UUID,
+			category: 'security',
+			severity: 'critical',
+			status: 'open',
+			limit: 10
+		}, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				category: 'security',
+				severity: 'critical',
+				status: 'open',
+				limit: 10,
+			})
+		);
+	});
+
+	it('should pass summary_only parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 0, has_more: false },
+		});
+		const ctx = createMockContext();
+
+		await getFindings({
+			project_id: VALID_UUID,
+			summary_only: true
+		}, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				summary_only: true,
+			})
+		);
+	});
+
+	it('should pass search_query parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 0, has_more: false },
+		});
+		const ctx = createMockContext();
+
+		await getFindings({
+			project_id: VALID_UUID,
+			search_query: 'security'
+		}, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				search_query: 'security',
+			})
+		);
+	});
+
+	it('should pass offset parameter to API client', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [], total_count: 100, has_more: true },
+		});
+		const ctx = createMockContext();
+
+		await getFindings({
+			project_id: VALID_UUID,
+			offset: 50,
+			limit: 25
+		}, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				offset: 50,
+				limit: 25,
+			})
+		);
+	});
+
+	it('should use default limit of 10 and summary_only true', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await getFindings({ project_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.getFindings).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ limit: 10, summary_only: true })
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.getFindings.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await getFindings({ project_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
+	});
+});
+
+// ============================================================================
+// updateFinding Tests
+// ============================================================================
+
+describe('updateFinding', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing finding_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(updateFinding({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid finding_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			updateFinding({ finding_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should update title', async () => {
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true, finding_id: VALID_UUID },
+		});
+		const ctx = createMockContext();
+
+		const result = await updateFinding(
+			{ finding_id: VALID_UUID, title: 'Updated Title' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({ success: true, finding_id: VALID_UUID });
+	});
+
+	it('should call API client with all update fields', async () => {
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		await updateFinding(
+			{
+				finding_id: VALID_UUID,
+				title: 'New Title',
+				description: 'New description',
+				severity: 'high',
+				status: 'addressed',
+				resolution_note: 'Fixed by sanitizing input'
+			},
+			ctx
+		);
+
+		expect(mockApiClient.updateFinding).toHaveBeenCalledWith(
+			VALID_UUID,
+			{
+				title: 'New Title',
+				description: 'New description',
+				severity: 'high',
+				status: 'addressed',
+				resolution_note: 'Fixed by sanitizing input',
+			}
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.updateFinding.mockResolvedValue({
+			ok: false,
+			error: 'Update failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await updateFinding({ finding_id: VALID_UUID, title: 'Test' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Update failed' });
+	});
+});
+
+// ============================================================================
+// deleteFinding Tests
+// ============================================================================
+
+describe('deleteFinding', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing finding_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(deleteFinding({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid finding_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			deleteFinding({ finding_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete finding successfully', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({ success: true });
+	});
+
+	it('should call API client deleteFinding', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		await deleteFinding({ finding_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.deleteFinding).toHaveBeenCalledWith(VALID_UUID);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.deleteFinding.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteFinding({ finding_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Delete failed' });
+	});
+});
+
+// ============================================================================
+// getFindingsStats Tests
+// ============================================================================
+
+describe('getFindingsStats', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getFindingsStats({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getFindingsStats({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return findings stats for project', async () => {
+		const mockStats = {
+			total: 10,
+			by_status: { open: 5, addressed: 3, dismissed: 2 },
+			by_severity: { critical: 1, high: 3, medium: 4, low: 2 },
+			by_category: { security: 3, performance: 4, code_quality: 3 },
+		};
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: true,
+			data: mockStats,
+		});
+		const ctx = createMockContext();
+
+		const result = await getFindingsStats({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject(mockStats);
+	});
+
+	it('should call API client getFindingsStats with project_id', async () => {
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: true,
+			data: { total: 0, by_status: {}, by_severity: {}, by_category: {} },
+		});
+		const ctx = createMockContext();
+
+		await getFindingsStats({ project_id: VALID_UUID }, ctx);
+
+		expect(mockApiClient.getFindingsStats).toHaveBeenCalledWith(VALID_UUID);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.getFindingsStats.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await getFindingsStats({ project_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
+	});
+});
+
+// ============================================================================
+// queryKnowledgeBase Tests
+// ============================================================================
+
+describe('queryKnowledgeBase', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(queryKnowledgeBase({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			queryKnowledgeBase({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid scope value', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			queryKnowledgeBase({ project_id: VALID_UUID, scope: 'invalid_scope' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should query with default parameters', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: {
+				findings: [],
+				decisions: [],
+				completed_tasks: [],
+				resolved_blockers: [],
+			},
+		});
+		const ctx = createMockContext();
+
+		const result = await queryKnowledgeBase({ project_id: VALID_UUID }, ctx);
+
+		expect(result.result).toMatchObject({
+			findings: [],
+			decisions: [],
+		});
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				scope: 'summary',
+				limit: 5,
+			})
+		);
+	});
+
+	it('should pass scope parameter', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await queryKnowledgeBase({ project_id: VALID_UUID, scope: 'detailed' }, ctx);
+
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ scope: 'detailed' })
+		);
+	});
+
+	it('should pass categories filter', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: { findings: [], decisions: [] },
+		});
+		const ctx = createMockContext();
+
+		await queryKnowledgeBase({
+			project_id: VALID_UUID,
+			categories: ['findings', 'decisions']
+		}, ctx);
+
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({
+				categories: ['findings', 'decisions']
+			})
+		);
+	});
+
+	it('should cap limit at 20', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await queryKnowledgeBase({ project_id: VALID_UUID, limit: 100 }, ctx);
+
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ limit: 20 })
+		);
+	});
+
+	it('should enforce minimum limit of 1', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await queryKnowledgeBase({ project_id: VALID_UUID, limit: -5 }, ctx);
+
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ limit: 1 })
+		);
+	});
+
+	it('should pass search_query', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: true,
+			data: { findings: [] },
+		});
+		const ctx = createMockContext();
+
+		await queryKnowledgeBase({
+			project_id: VALID_UUID,
+			search_query: 'security'
+		}, ctx);
+
+		expect(mockApiClient.queryKnowledgeBase).toHaveBeenCalledWith(
+			VALID_UUID,
+			expect.objectContaining({ search_query: 'security' })
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.queryKnowledgeBase.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await queryKnowledgeBase({ project_id: VALID_UUID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
+	});
+});