@vibescope/mcp-server 0.2.0 → 0.2.2

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

@@ -60,7 +60,7 @@ describe('addGitIssue', () => {
 				issue_type: 'invalid_type',
 				branch: 'feature/test',
 			}, ctx)
-		).rejects.toThrow('Invalid issue_type');
+		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid task_id UUID', async () => {
@@ -180,35 +180,37 @@ describe('addGitIssue', () => {
 		}
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.addGitIssue.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			addGitIssue({
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'merge_conflict',
-				branch: 'feature/test',
-			}, ctx)
-		).rejects.toThrow('Insert failed');
+		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 throw default error message when API fails without error', async () => {
+	it('should return default error message when API fails without error', async () => {
 		mockApiClient.addGitIssue.mockResolvedValue({
 			ok: false,
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			addGitIssue({
-				project_id: VALID_PROJECT_ID,
-				issue_type: 'merge_conflict',
-				branch: 'feature/test',
-			}, ctx)
-		).rejects.toThrow('Failed to add git issue');
+		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' });
 	});
 });
 
@@ -314,27 +316,29 @@ describe('resolveGitIssue', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.resolveGitIssue.mockResolvedValue({
 			ok: false,
 			error: 'Update failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
-		).rejects.toThrow('Update failed');
+		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 throw default error message when API fails without error', async () => {
+	it('should return default error message when API fails without error', async () => {
 		mockApiClient.resolveGitIssue.mockResolvedValue({
 			ok: false,
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			resolveGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
-		).rejects.toThrow('Failed to resolve git issue');
+		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' });
 	});
 });
 
@@ -364,7 +368,7 @@ describe('getGitIssues', () => {
 
 		await expect(
 			getGitIssues({ project_id: VALID_PROJECT_ID, status: 'invalid_status' }, ctx)
-		).rejects.toThrow('Invalid status');
+		).rejects.toThrow(ValidationError);
 	});
 
 	it('should throw error for invalid issue_type filter', async () => {
@@ -372,7 +376,7 @@ describe('getGitIssues', () => {
 
 		await expect(
 			getGitIssues({ project_id: VALID_PROJECT_ID, issue_type: 'invalid_type' }, ctx)
-		).rejects.toThrow('Invalid issue_type');
+		).rejects.toThrow(ValidationError);
 	});
 
 	it('should return empty list when no git issues', async () => {
@@ -519,27 +523,29 @@ describe('getGitIssues', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.getGitIssues.mockResolvedValue({
 			ok: false,
 			error: 'Query failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getGitIssues({ project_id: VALID_PROJECT_ID }, ctx)
-		).rejects.toThrow('Query failed');
+		const result = await getGitIssues({ project_id: VALID_PROJECT_ID }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
 	});
 
-	it('should throw default error message when API fails without error', async () => {
+	it('should return default error message when API fails without error', async () => {
 		mockApiClient.getGitIssues.mockResolvedValue({
 			ok: false,
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getGitIssues({ project_id: VALID_PROJECT_ID }, ctx)
-		).rejects.toThrow('Failed to fetch git issues');
+		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' });
 	});
 });
 
@@ -598,26 +604,28 @@ describe('deleteGitIssue', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.deleteGitIssue.mockResolvedValue({
 			ok: false,
 			error: 'Delete failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
-		).rejects.toThrow('Delete failed');
+		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 throw default error message when API fails without error', async () => {
+	it('should return default error message when API fails without error', async () => {
 		mockApiClient.deleteGitIssue.mockResolvedValue({
 			ok: false,
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteGitIssue({ git_issue_id: VALID_GIT_ISSUE_ID }, ctx)
-		).rejects.toThrow('Failed to delete git issue');
+		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' });
 	});
 });

package/src/handlers/git-issues.ts

@@ -9,7 +9,7 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
 const VALID_GIT_ISSUE_TYPES = [
@@ -25,41 +25,38 @@ const VALID_GIT_ISSUE_STATUSES = ['open', 'resolved'] as const;
 type GitIssueType = (typeof VALID_GIT_ISSUE_TYPES)[number];
 type GitIssueStatus = (typeof VALID_GIT_ISSUE_STATUSES)[number];
 
-export const addGitIssue: Handler = async (args, ctx) => {
-	const {
-		project_id,
-		issue_type,
-		branch,
-		target_branch,
-		pr_url,
-		conflicting_files,
-		error_message,
-		task_id,
-	} = args as {
-		project_id: string;
-		issue_type: string;
-		branch: string;
-		target_branch?: string;
-		pr_url?: string;
-		conflicting_files?: string[];
-		error_message?: string;
-		task_id?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(issue_type, 'issue_type');
-	validateRequired(branch, 'branch');
-
-	if (!VALID_GIT_ISSUE_TYPES.includes(issue_type as GitIssueType)) {
-		throw new Error(
-			`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`
-		);
-	}
+// Argument schemas for type-safe parsing
+const addGitIssueSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	issue_type: { type: 'string' as const, required: true as const, validate: createEnumValidator(VALID_GIT_ISSUE_TYPES) },
+	branch: { type: 'string' as const, required: true as const },
+	target_branch: { type: 'string' as const },
+	pr_url: { type: 'string' as const },
+	conflicting_files: { type: 'array' as const },
+	error_message: { type: 'string' as const },
+	task_id: { type: 'string' as const, validate: uuidValidator },
+};
 
-	if (task_id) {
-		validateUUID(task_id, 'task_id');
-	}
+const resolveGitIssueSchema = {
+	git_issue_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	resolution_note: { type: 'string' as const },
+	auto_resolved: { type: 'boolean' as const },
+};
+
+const getGitIssuesSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, default: 'open', validate: createEnumValidator(VALID_GIT_ISSUE_STATUSES) },
+	issue_type: { type: 'string' as const, validate: createEnumValidator(VALID_GIT_ISSUE_TYPES) },
+	branch: { type: 'string' as const },
+	limit: { type: 'number' as const, default: 50 },
+};
+
+const deleteGitIssueSchema = {
+	git_issue_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const addGitIssue: Handler = async (args, ctx) => {
+	const { project_id, issue_type, branch, target_branch, pr_url, conflicting_files, error_message, task_id } = parseArgs(args, addGitIssueSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.addGitIssue(project_id, {
@@ -67,27 +64,20 @@ export const addGitIssue: Handler = async (args, ctx) => {
 		branch,
 		target_branch,
 		pr_url,
-		conflicting_files,
+		conflicting_files: conflicting_files as string[] | undefined,
 		error_message,
 		task_id
 	}, ctx.session.currentSessionId || undefined);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to add git issue');
+		return { result: { error: response.error || 'Failed to add git issue' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
 export const resolveGitIssue: Handler = async (args, ctx) => {
-	const { git_issue_id, resolution_note, auto_resolved } = args as {
-		git_issue_id: string;
-		resolution_note?: string;
-		auto_resolved?: boolean;
-	};
-
-	validateRequired(git_issue_id, 'git_issue_id');
-	validateUUID(git_issue_id, 'git_issue_id');
+	const { git_issue_id, resolution_note, auto_resolved } = parseArgs(args, resolveGitIssueSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.resolveGitIssue(git_issue_id, {
@@ -96,68 +86,38 @@ export const resolveGitIssue: Handler = async (args, ctx) => {
 	}, ctx.session.currentSessionId || undefined);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to resolve git issue');
+		return { result: { error: response.error || 'Failed to resolve git issue' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
-export const getGitIssues: Handler = async (args, ctx) => {
-	const {
-		project_id,
-		status = 'open',
-		issue_type,
-		branch,
-		limit = 50,
-	} = args as {
-		project_id: string;
-		status?: string;
-		issue_type?: string;
-		branch?: string;
-		limit?: number;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
-	if (status && !VALID_GIT_ISSUE_STATUSES.includes(status as GitIssueStatus)) {
-		throw new Error(
-			`Invalid status. Valid statuses: ${VALID_GIT_ISSUE_STATUSES.join(', ')}`
-		);
-	}
-
-	if (issue_type && !VALID_GIT_ISSUE_TYPES.includes(issue_type as GitIssueType)) {
-		throw new Error(
-			`Invalid issue_type. Valid types: ${VALID_GIT_ISSUE_TYPES.join(', ')}`
-		);
-	}
+export const getGitIssues: Handler = async (args, _ctx) => {
+	const { project_id, status, issue_type, branch, limit } = parseArgs(args, getGitIssuesSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getGitIssues(project_id, {
-		status,
-		issue_type,
+		status: status as GitIssueStatus | undefined,
+		issue_type: issue_type as GitIssueType | undefined,
 		branch,
 		limit
 	});
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to fetch git issues');
+		return { result: { error: response.error || 'Failed to fetch git issues' }, isError: true };
 	}
 
 	return { result: response.data };
 };
 
-export const deleteGitIssue: Handler = async (args, ctx) => {
-	const { git_issue_id } = args as { git_issue_id: string };
-
-	validateRequired(git_issue_id, 'git_issue_id');
-	validateUUID(git_issue_id, 'git_issue_id');
+export const deleteGitIssue: Handler = async (args, _ctx) => {
+	const { git_issue_id } = parseArgs(args, deleteGitIssueSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteGitIssue(git_issue_id);
 
 	if (!response.ok) {
-		throw new Error(response.error || 'Failed to delete git issue');
+		return { result: { error: response.error || 'Failed to delete git issue' }, isError: true };
 	}
 
 	return { result: response.data };

package/src/handlers/ideas.test.ts

@@ -138,19 +138,20 @@ describe('addIdea', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.addIdea.mockResolvedValue({
 			ok: false,
 			error: 'Insert failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			addIdea({
-				project_id: '123e4567-e89b-12d3-a456-426614174000',
-				title: 'New Feature',
-			}, ctx)
-		).rejects.toThrow('Failed to add idea');
+		const result = await addIdea({
+			project_id: '123e4567-e89b-12d3-a456-426614174000',
+			title: 'New Feature',
+		}, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Insert failed' });
 	});
 });
 
@@ -248,16 +249,17 @@ describe('updateIdea', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.updateIdea.mockResolvedValue({
 			ok: false,
 			error: 'Idea not found',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			updateIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000', title: 'New' }, ctx)
-		).rejects.toThrow('Failed to update idea');
+		const result = await updateIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000', title: 'New' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Idea not found' });
 	});
 });
 
@@ -363,16 +365,17 @@ describe('getIdeas', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.getIdeas.mockResolvedValue({
 			ok: false,
 			error: 'Query failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			getIdeas({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to fetch ideas');
+		const result = await getIdeas({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Query failed' });
 	});
 });
 
@@ -429,16 +432,17 @@ describe('deleteIdea', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.deleteIdea.mockResolvedValue({
 			ok: false,
 			error: 'Delete failed',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			deleteIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to delete idea');
+		const result = await deleteIdea({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Delete failed' });
 	});
 });
 
@@ -625,15 +629,16 @@ describe('convertIdeaToTask', () => {
 		);
 	});
 
-	it('should throw error when API call fails', async () => {
+	it('should return error when API call fails', async () => {
 		mockApiClient.proxy.mockResolvedValue({
 			ok: false,
 			error: 'Idea not found',
 		});
 		const ctx = createMockContext();
 
-		await expect(
-			convertIdeaToTask({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
-		).rejects.toThrow('Failed to convert idea');
+		const result = await convertIdeaToTask({ idea_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx);
+
+		expect(result.isError).toBe(true);
+		expect(result.result).toMatchObject({ error: 'Idea not found' });
 	});
 });