@vibescope/mcp-server 0.5.0 → 0.5.2

package/src/handlers/git-issues.test.ts

@@ -1,631 +1,631 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-	addGitIssue,
-	resolveGitIssue,
-	getGitIssues,
-	deleteGitIssue,
-} from './git-issues.js';
-import { ValidationError } from '../validators.js';
-import { createMockContext } from './__test-utils__.js';
-import { mockApiClient } from './__test-setup__.js';
-
-const VALID_PROJECT_ID = '123e4567-e89b-12d3-a456-426614174000';
-const VALID_GIT_ISSUE_ID = '987e6543-e21b-12d3-a456-426614174000';
-
-// ============================================================================
-// addGitIssue Tests
-// ============================================================================
-
-describe('addGitIssue', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({ issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({ project_id: 'invalid', issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for missing issue_type', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({ project_id: VALID_PROJECT_ID, branch: 'feature/test' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for missing branch', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid issue_type', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'invalid_type',
-				branch: 'feature/test',
-			}, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid task_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			addGitIssue({
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'merge_conflict',
-				branch: 'feature/test',
-				task_id: 'invalid-uuid',
-			}, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should add git issue successfully', async () => {
-		mockApiClient.addGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext();
-
-		const result = await addGitIssue(
-			{
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'merge_conflict',
-				branch: 'feature/test',
-			},
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-			git_issue_id: VALID_GIT_ISSUE_ID,
-		});
-	});
-
-	it('should add git issue with all optional fields', async () => {
-		mockApiClient.addGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext({ sessionId: 'test-session' });
-
-		await addGitIssue(
-			{
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'pr_not_mergeable',
-				branch: 'feature/test',
-				target_branch: 'main',
-				pr_url: 'https://github.com/org/repo/pull/123',
-				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
-				error_message: 'Merge conflict in file1.ts',
-				task_id: VALID_GIT_ISSUE_ID,
-			},
-			ctx
-		);
-
-		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			{
-				issue_type: 'pr_not_mergeable',
-				branch: 'feature/test',
-				target_branch: 'main',
-				pr_url: 'https://github.com/org/repo/pull/123',
-				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
-				error_message: 'Merge conflict in file1.ts',
-				task_id: VALID_GIT_ISSUE_ID,
-			},
-			'test-session'
-		);
-	});
-
-	it('should include session_id in API call', async () => {
-		mockApiClient.addGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext({ sessionId: 'my-session' });
-
-		await addGitIssue(
-			{
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'push_failed',
-				branch: 'feature/test',
-			},
-			ctx
-		);
-
-		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({
-				issue_type: 'push_failed',
-				branch: 'feature/test',
-			}),
-			'my-session'
-		);
-	});
-
-	it('should accept all valid issue types', async () => {
-		const validTypes = ['merge_conflict', 'push_failed', 'rebase_needed', 'branch_diverged', 'pr_not_mergeable'];
-		const ctx = createMockContext();
-
-		for (const issueType of validTypes) {
-			mockApiClient.addGitIssue.mockResolvedValue({
-				ok: true,
-				data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-			});
-
-			await expect(
-				addGitIssue({
-					project_id: VALID_PROJECT_ID,
-					issue_type: issueType,
-					branch: 'feature/test',
-				}, ctx)
-			).resolves.not.toThrow();
-		}
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.addGitIssue.mockResolvedValue({
-			ok: false,
-			error: 'Insert failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await addGitIssue({
-			project_id: VALID_PROJECT_ID,
-			issue_type: 'merge_conflict',
-			branch: 'feature/test',
-		}, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Insert failed' });
-	});
-
-	it('should return default error message when API fails without error', async () => {
-		mockApiClient.addGitIssue.mockResolvedValue({
-			ok: false,
-		});
-		const ctx = createMockContext();
-
-		const result = await addGitIssue({
-			project_id: VALID_PROJECT_ID,
-			issue_type: 'merge_conflict',
-			branch: 'feature/test',
-		}, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Failed to add git issue' });
-	});
-});
-
-// ============================================================================
-// resolveGitIssue Tests
-// ============================================================================
-
-describe('resolveGitIssue', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing git_issue_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(resolveGitIssue({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid git_issue_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			resolveGitIssue({ git_issue_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should resolve git issue successfully', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext();
-
-		const result = await resolveGitIssue(
-			{ git_issue_id: VALID_GIT_ISSUE_ID },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-			git_issue_id: VALID_GIT_ISSUE_ID,
-		});
-	});
-
-	it('should resolve git issue with resolution_note', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext({ sessionId: 'test-session' });
-
-		await resolveGitIssue(
-			{
-				git_issue_id: VALID_GIT_ISSUE_ID,
-				resolution_note: 'Resolved by rebasing',
-			},
-			ctx
-		);
-
-		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
-			VALID_GIT_ISSUE_ID,
-			{ resolution_note: 'Resolved by rebasing', auto_resolved: undefined },
-			'test-session'
-		);
-	});
-
-	it('should resolve git issue with auto_resolved flag', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext({ sessionId: 'test-session' });
-
-		await resolveGitIssue(
-			{
-				git_issue_id: VALID_GIT_ISSUE_ID,
-				auto_resolved: true,
-			},
-			ctx
-		);
-
-		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
-			VALID_GIT_ISSUE_ID,
-			{ resolution_note: undefined, auto_resolved: true },
-			'test-session'
-		);
-	});
-
-	it('should include session_id in API call', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
-		});
-		const ctx = createMockContext({ sessionId: 'my-session' });
-
-		await resolveGitIssue(
-			{ git_issue_id: VALID_GIT_ISSUE_ID },
-			ctx
-		);
-
-		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
-			VALID_GIT_ISSUE_ID,
-			expect.any(Object),
-			'my-session'
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: false,
-			error: 'Update failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Update failed' });
-	});
-
-	it('should return default error message when API fails without error', async () => {
-		mockApiClient.resolveGitIssue.mockResolvedValue({
-			ok: false,
-		});
-		const ctx = createMockContext();
-
-		const result = await resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Failed to resolve git issue' });
-	});
-});
-
-// ============================================================================
-// getGitIssues Tests
-// ============================================================================
-
-describe('getGitIssues', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing project_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(getGitIssues({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid project_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getGitIssues({ project_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid status', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getGitIssues({ project_id: VALID_PROJECT_ID, status: 'invalid_status' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid issue_type filter', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			getGitIssues({ project_id: VALID_PROJECT_ID, issue_type: 'invalid_type' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should return empty list when no git issues', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		const result = await getGitIssues(
-			{ project_id: VALID_PROJECT_ID },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			git_issues: [],
-		});
-	});
-
-	it('should return git issues list', async () => {
-		const mockGitIssues = [
-			{ id: 'gi1', issue_type: 'merge_conflict', branch: 'feature/a', status: 'open', created_at: '2025-01-14T10:00:00Z' },
-			{ id: 'gi2', issue_type: 'push_failed', branch: 'feature/b', status: 'open', created_at: '2025-01-14T11:00:00Z' },
-		];
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: mockGitIssues },
-		});
-		const ctx = createMockContext();
-
-		const result = await getGitIssues(
-			{ project_id: VALID_PROJECT_ID },
-			ctx
-		);
-
-		expect((result.result as { git_issues: unknown[] }).git_issues).toHaveLength(2);
-	});
-
-	it('should pass status parameter to API (default: open)', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ status: 'open' })
-		);
-	});
-
-	it('should pass custom status to API', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID, status: 'resolved' },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ status: 'resolved' })
-		);
-	});
-
-	it('should pass issue_type filter to API', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ issue_type: 'merge_conflict' })
-		);
-	});
-
-	it('should pass branch filter to API', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID, branch: 'feature/test' },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ branch: 'feature/test' })
-		);
-	});
-
-	it('should pass limit parameter to API (default: 50)', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ limit: 50, offset: 0 })
-		);
-	});
-
-	it('should pass custom limit to API', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: true,
-			data: { git_issues: [] },
-		});
-		const ctx = createMockContext();
-
-		await getGitIssues(
-			{ project_id: VALID_PROJECT_ID, limit: 10 },
-			ctx
-		);
-
-		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
-			VALID_PROJECT_ID,
-			expect.objectContaining({ limit: 10, offset: 0 })
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: false,
-			error: 'Query failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await getGitIssues({ project_id: VALID_PROJECT_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Query failed' });
-	});
-
-	it('should return default error message when API fails without error', async () => {
-		mockApiClient.getGitIssues.mockResolvedValue({
-			ok: false,
-		});
-		const ctx = createMockContext();
-
-		const result = await getGitIssues({ project_id: VALID_PROJECT_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Failed to fetch git issues' });
-	});
-});
-
-// ============================================================================
-// deleteGitIssue Tests
-// ============================================================================
-
-describe('deleteGitIssue', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('should throw error for missing git_issue_id', async () => {
-		const ctx = createMockContext();
-
-		await expect(deleteGitIssue({}, ctx)).rejects.toThrow(ValidationError);
-	});
-
-	it('should throw error for invalid git_issue_id UUID', async () => {
-		const ctx = createMockContext();
-
-		await expect(
-			deleteGitIssue({ git_issue_id: 'invalid' }, ctx)
-		).rejects.toThrow(ValidationError);
-	});
-
-	it('should delete git issue successfully', async () => {
-		mockApiClient.deleteGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-		const ctx = createMockContext();
-
-		const result = await deleteGitIssue(
-			{ git_issue_id: VALID_GIT_ISSUE_ID },
-			ctx
-		);
-
-		expect(result.result).toMatchObject({
-			success: true,
-		});
-	});
-
-	it('should call API client deleteGitIssue', async () => {
-		mockApiClient.deleteGitIssue.mockResolvedValue({
-			ok: true,
-			data: { success: true },
-		});
-		const ctx = createMockContext();
-
-		await deleteGitIssue(
-			{ git_issue_id: VALID_GIT_ISSUE_ID },
-			ctx
-		);
-
-		expect(mockApiClient.deleteGitIssue).toHaveBeenCalledWith(
-			VALID_GIT_ISSUE_ID
-		);
-	});
-
-	it('should return error when API call fails', async () => {
-		mockApiClient.deleteGitIssue.mockResolvedValue({
-			ok: false,
-			error: 'Delete failed',
-		});
-		const ctx = createMockContext();
-
-		const result = await deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Delete failed' });
-	});
-
-	it('should return default error message when API fails without error', async () => {
-		mockApiClient.deleteGitIssue.mockResolvedValue({
-			ok: false,
-		});
-		const ctx = createMockContext();
-
-		const result = await deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
-
-		expect(result.isError).toBe(true);
-		expect(result.result).toMatchObject({ error: 'Failed to delete git issue' });
-	});
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	addGitIssue,
+	resolveGitIssue,
+	getGitIssues,
+	deleteGitIssue,
+} from './git-issues.js';
+import { ValidationError } from '../validators.js';
+import { createMockContext } from './__test-utils__.js';
+import { mockApiClient } from './__test-setup__.js';
+
+const VALID_PROJECT_ID = '123e4567-e89b-12d3-a456-426614174000';
+const VALID_GIT_ISSUE_ID = '987e6543-e21b-12d3-a456-426614174000';
+
+// ============================================================================
+// addGitIssue Tests
+// ============================================================================
+
+describe('addGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: 'invalid', issue_type: 'merge_conflict', branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing issue_type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: VALID_PROJECT_ID, branch: 'feature/test' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing branch', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid issue_type', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'invalid_type',
+				branch: 'feature/test',
+			}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid task_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			addGitIssue({
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+				task_id: 'invalid-uuid',
+			}, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should add git issue successfully', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext();
+
+		const result = await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'merge_conflict',
+				branch: 'feature/test',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			git_issue_id: VALID_GIT_ISSUE_ID,
+		});
+	});
+
+	it('should add git issue with all optional fields', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'pr_not_mergeable',
+				branch: 'feature/test',
+				target_branch: 'main',
+				pr_url: 'https://github.com/org/repo/pull/123',
+				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
+				error_message: 'Merge conflict in file1.ts',
+				task_id: VALID_GIT_ISSUE_ID,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			{
+				issue_type: 'pr_not_mergeable',
+				branch: 'feature/test',
+				target_branch: 'main',
+				pr_url: 'https://github.com/org/repo/pull/123',
+				conflicting_files: ['src/file1.ts', 'src/file2.ts'],
+				error_message: 'Merge conflict in file1.ts',
+				task_id: VALID_GIT_ISSUE_ID,
+			},
+			'test-session'
+		);
+	});
+
+	it('should include session_id in API call', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await addGitIssue(
+			{
+				project_id: VALID_PROJECT_ID,
+				issue_type: 'push_failed',
+				branch: 'feature/test',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.addGitIssue).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({
+				issue_type: 'push_failed',
+				branch: 'feature/test',
+			}),
+			'my-session'
+		);
+	});
+
+	it('should accept all valid issue types', async () => {
+		const validTypes = ['merge_conflict', 'push_failed', 'rebase_needed', 'branch_diverged', 'pr_not_mergeable'];
+		const ctx = createMockContext();
+
+		for (const issueType of validTypes) {
+			mockApiClient.addGitIssue.mockResolvedValue({
+				ok: true,
+				data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+			});
+
+			await expect(
+				addGitIssue({
+					project_id: VALID_PROJECT_ID,
+					issue_type: issueType,
+					branch: 'feature/test',
+				}, ctx)
+			).resolves.not.toThrow();
+		}
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Insert failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await addGitIssue({
+			project_id: VALID_PROJECT_ID,
+			issue_type: 'merge_conflict',
+			branch: 'feature/test',
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Insert failed' });
+	});
+
+	it('should return default error message when API fails without error', async () => {
+		mockApiClient.addGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		const result = await addGitIssue({
+			project_id: VALID_PROJECT_ID,
+			issue_type: 'merge_conflict',
+			branch: 'feature/test',
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Failed to add git issue' });
+	});
+});
+
+// ============================================================================
+// resolveGitIssue Tests
+// ============================================================================
+
+describe('resolveGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing git_issue_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(resolveGitIssue({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid git_issue_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			resolveGitIssue({ git_issue_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should resolve git issue successfully', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext();
+
+		const result = await resolveGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			git_issue_id: VALID_GIT_ISSUE_ID,
+		});
+	});
+
+	it('should resolve git issue with resolution_note', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await resolveGitIssue(
+			{
+				git_issue_id: VALID_GIT_ISSUE_ID,
+				resolution_note: 'Resolved by rebasing',
+			},
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			{ resolution_note: 'Resolved by rebasing', auto_resolved: undefined },
+			'test-session'
+		);
+	});
+
+	it('should resolve git issue with auto_resolved flag', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'test-session' });
+
+		await resolveGitIssue(
+			{
+				git_issue_id: VALID_GIT_ISSUE_ID,
+				auto_resolved: true,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			{ resolution_note: undefined, auto_resolved: true },
+			'test-session'
+		);
+	});
+
+	it('should include session_id in API call', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true, git_issue_id: VALID_GIT_ISSUE_ID },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await resolveGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(mockApiClient.resolveGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID,
+			expect.any(Object),
+			'my-session'
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Update failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Update failed' });
+	});
+
+	it('should return default error message when API fails without error', async () => {
+		mockApiClient.resolveGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		const result = await resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Failed to resolve git issue' });
+	});
+});
+
+// ============================================================================
+// getGitIssues Tests
+// ============================================================================
+
+describe('getGitIssues', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(getGitIssues({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid status', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID, status: 'invalid_status' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid issue_type filter', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			getGitIssues({ project_id: VALID_PROJECT_ID, issue_type: 'invalid_type' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no git issues', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			git_issues: [],
+		});
+	});
+
+	it('should return git issues list', async () => {
+		const mockGitIssues = [
+			{ id: 'gi1', issue_type: 'merge_conflict', branch: 'feature/a', status: 'open', created_at: '2025-01-14T10:00:00Z' },
+			{ id: 'gi2', issue_type: 'push_failed', branch: 'feature/b', status: 'open', created_at: '2025-01-14T11:00:00Z' },
+		];
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: mockGitIssues },
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect((result.result as { git_issues: unknown[] }).git_issues).toHaveLength(2);
+	});
+
+	it('should pass status parameter to API (default: open)', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ status: 'open' })
+		);
+	});
+
+	it('should pass custom status to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, status: 'resolved' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ status: 'resolved' })
+		);
+	});
+
+	it('should pass issue_type filter to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, issue_type: 'merge_conflict' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ issue_type: 'merge_conflict' })
+		);
+	});
+
+	it('should pass branch filter to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, branch: 'feature/test' },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ branch: 'feature/test' })
+		);
+	});
+
+	it('should pass limit parameter to API (default: 50)', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ limit: 50, offset: 0 })
+		);
+	});
+
+	it('should pass custom limit to API', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: true,
+			data: { git_issues: [] },
+		});
+		const ctx = createMockContext();
+
+		await getGitIssues(
+			{ project_id: VALID_PROJECT_ID, limit: 10 },
+			ctx
+		);
+
+		expect(mockApiClient.getGitIssues).toHaveBeenCalledWith(
+			VALID_PROJECT_ID,
+			expect.objectContaining({ limit: 10, offset: 0 })
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: false,
+			error: 'Query failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues({ project_id: VALID_PROJECT_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
+	});
+
+	it('should return default error message when API fails without error', async () => {
+		mockApiClient.getGitIssues.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		const result = await getGitIssues({ project_id: VALID_PROJECT_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Failed to fetch git issues' });
+	});
+});
+
+// ============================================================================
+// deleteGitIssue Tests
+// ============================================================================
+
+describe('deleteGitIssue', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing git_issue_id', async () => {
+		const ctx = createMockContext();
+
+		await expect(deleteGitIssue({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid git_issue_id UUID', async () => {
+		const ctx = createMockContext();
+
+		await expect(
+			deleteGitIssue({ git_issue_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete git issue successfully', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+	});
+
+	it('should call API client deleteGitIssue', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: true,
+			data: { success: true },
+		});
+		const ctx = createMockContext();
+
+		await deleteGitIssue(
+			{ git_issue_id: VALID_GIT_ISSUE_ID },
+			ctx
+		);
+
+		expect(mockApiClient.deleteGitIssue).toHaveBeenCalledWith(
+			VALID_GIT_ISSUE_ID
+		);
+	});
+
+	it('should return error when API call fails', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: false,
+			error: 'Delete failed',
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Delete failed' });
+	});
+
+	it('should return default error message when API fails without error', async () => {
+		mockApiClient.deleteGitIssue.mockResolvedValue({
+			ok: false,
+		});
+		const ctx = createMockContext();
+
+		const result = await deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Failed to delete git issue' });
+	});
+});