@vibescope/mcp-server 0.2.0 → 0.2.1

package/src/handlers/decisions.test.ts

@@ -198,7 +198,7 @@ describe('getDecisions', () => {
 		});
 	});
 
-	it('should call API client getDecisions', async () => {
+	it('should call API client getDecisions with options', async () => {
 		mockApiClient.getDecisions.mockResolvedValue({
 			ok: true,
 			data: { decisions: [] },
@@ -211,7 +211,8 @@ describe('getDecisions', () => {
 		);
 
 		expect(mockApiClient.getDecisions).toHaveBeenCalledWith(
-			'123e4567-e89b-12d3-a456-426614174000'
+			'123e4567-e89b-12d3-a456-426614174000',
+			{ limit: 50, offset: 0, search_query: undefined }
 		);
 	});
 

package/src/handlers/decisions.ts

@@ -10,22 +10,31 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const logDecision: Handler = async (args, ctx) => {
-	const { project_id, title, description, rationale, alternatives_considered } = args as {
-		project_id: string;
-		title: string;
-		description: string;
-		rationale?: string;
-		alternatives_considered?: string[];
-	};
+// Argument schemas for type-safe parsing
+const logDecisionSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const, required: true as const },
+	rationale: { type: 'string' as const },
+	alternatives_considered: { type: 'array' as const },
+};
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(title, 'title');
-	validateRequired(description, 'description');
+const getDecisionsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	limit: { type: 'number' as const, default: 50 },
+	offset: { type: 'number' as const, default: 0 },
+	search_query: { type: 'string' as const },
+};
+
+const deleteDecisionSchema = {
+	decision_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const logDecision: Handler = async (args, ctx) => {
+	const { project_id, title, description, rationale, alternatives_considered } = parseArgs(args, logDecisionSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
@@ -34,7 +43,7 @@ export const logDecision: Handler = async (args, ctx) => {
 		title,
 		description,
 		rationale,
-		alternatives_considered
+		alternatives_considered: alternatives_considered as string[] | undefined
 	}, session.currentSessionId || undefined);
 
 	if (!response.ok) {
@@ -44,17 +53,16 @@ export const logDecision: Handler = async (args, ctx) => {
 	return { result: { success: true, title, decision_id: response.data?.decision_id } };
 };
 
-export const getDecisions: Handler = async (args, ctx) => {
-	const { project_id } = args as {
-		project_id: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+export const getDecisions: Handler = async (args, _ctx) => {
+	const { project_id, limit, offset, search_query } = parseArgs(args, getDecisionsSchema);
 
 	const apiClient = getApiClient();
 
-	const response = await apiClient.getDecisions(project_id);
+	const response = await apiClient.getDecisions(project_id, {
+		limit,
+		offset,
+		search_query
+	});
 
 	if (!response.ok) {
 		throw new Error(`Failed to fetch decisions: ${response.error}`);
@@ -67,11 +75,8 @@ export const getDecisions: Handler = async (args, ctx) => {
 	};
 };
 
-export const deleteDecision: Handler = async (args, ctx) => {
-	const { decision_id } = args as { decision_id: string };
-
-	validateRequired(decision_id, 'decision_id');
-	validateUUID(decision_id, 'decision_id');
+export const deleteDecision: Handler = async (args, _ctx) => {
+	const { decision_id } = parseArgs(args, deleteDecisionSchema);
 
 	const apiClient = getApiClient();
 

package/src/handlers/deployment.ts

@@ -17,34 +17,132 @@
 import type { Handler, HandlerRegistry } from './types.js';
 import {
 	ValidationError,
-	validateRequired,
-	validateUUID,
-	validateEnvironment,
+	parseArgs,
+	uuidValidator,
+	createEnumValidator,
 } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 
-export const requestDeployment: Handler = async (args, ctx) => {
-	const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: 'patch' | 'minor' | 'major';
-		notes?: string;
-		git_ref?: string;
-	};
+const ENVIRONMENTS = ['development', 'staging', 'production'] as const;
+const VERSION_BUMPS = ['patch', 'minor', 'major'] as const;
+const REQUIREMENT_TYPES = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'] as const;
+const REQUIREMENT_STAGES = ['preparation', 'deployment', 'verification'] as const;
+const REQUIREMENT_STATUSES = ['pending', 'completed', 'converted_to_task', 'all'] as const;
+const SCHEDULE_TYPES = ['once', 'daily', 'weekly', 'monthly'] as const;
 
-	const { session } = ctx;
+type Environment = typeof ENVIRONMENTS[number];
+type VersionBump = typeof VERSION_BUMPS[number];
+type RequirementType = typeof REQUIREMENT_TYPES[number];
+type RequirementStage = typeof REQUIREMENT_STAGES[number];
+type RequirementStatus = typeof REQUIREMENT_STATUSES[number];
+type ScheduleType = typeof SCHEDULE_TYPES[number];
+
+// ============================================================================
+// Argument Schemas
+// ============================================================================
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateEnvironment(environment);
+const requestDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
 
-	if (version_bump && !['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-			hint: 'Must be one of: patch, minor, major',
-		});
-	}
+const claimDeploymentValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const reportValidationSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	build_passed: { type: 'boolean' as const, required: true as const },
+	tests_passed: { type: 'boolean' as const },
+	error_message: { type: 'string' as const },
+};
+
+const checkDeploymentStatusSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const startDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const completeDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	success: { type: 'boolean' as const, required: true as const },
+	summary: { type: 'string' as const },
+};
+
+const cancelDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	reason: { type: 'string' as const },
+};
+
+const addDeploymentRequirementSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	type: { type: 'string' as const, required: true as const, validate: createEnumValidator(REQUIREMENT_TYPES) },
+	title: { type: 'string' as const, required: true as const },
+	description: { type: 'string' as const },
+	file_path: { type: 'string' as const },
+	stage: { type: 'string' as const, default: 'preparation', validate: createEnumValidator(REQUIREMENT_STAGES) },
+	blocking: { type: 'boolean' as const, default: false },
+	recurring: { type: 'boolean' as const, default: false },
+};
+
+const completeDeploymentRequirementSchema = {
+	requirement_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const getDeploymentRequirementsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	status: { type: 'string' as const, default: 'pending', validate: createEnumValidator(REQUIREMENT_STATUSES) },
+	stage: { type: 'string' as const, validate: createEnumValidator([...REQUIREMENT_STAGES, 'all'] as const) },
+};
+
+const scheduleDeploymentSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+	schedule_type: { type: 'string' as const, default: 'once', validate: createEnumValidator(SCHEDULE_TYPES) },
+	scheduled_at: { type: 'string' as const, required: true as const },
+	auto_trigger: { type: 'boolean' as const, default: true },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const getScheduledDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	include_disabled: { type: 'boolean' as const, default: false },
+};
+
+const updateScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+	environment: { type: 'string' as const, validate: createEnumValidator(ENVIRONMENTS) },
+	version_bump: { type: 'string' as const, validate: createEnumValidator(VERSION_BUMPS) },
+	schedule_type: { type: 'string' as const, validate: createEnumValidator(SCHEDULE_TYPES) },
+	scheduled_at: { type: 'string' as const },
+	auto_trigger: { type: 'boolean' as const },
+	enabled: { type: 'boolean' as const },
+	notes: { type: 'string' as const },
+	git_ref: { type: 'string' as const },
+};
+
+const deleteScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const triggerScheduledDeploymentSchema = {
+	schedule_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+const checkDueDeploymentsSchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
+export const requestDeployment: Handler = async (args, ctx) => {
+	const { project_id, environment, version_bump, notes, git_ref } = parseArgs(args, requestDeploymentSchema);
+	const { session } = ctx;
 
 	const apiClient = getApiClient();
 	const response = await apiClient.requestDeployment(project_id, {
@@ -62,12 +160,9 @@ export const requestDeployment: Handler = async (args, ctx) => {
 };
 
 export const claimDeploymentValidation: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, claimDeploymentValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.claimDeploymentValidation(
 		project_id,
@@ -82,24 +177,9 @@ export const claimDeploymentValidation: Handler = async (args, ctx) => {
 };
 
 export const reportValidation: Handler = async (args, ctx) => {
-	const { project_id, build_passed, tests_passed, error_message } = args as {
-		project_id: string;
-		build_passed: boolean;
-		tests_passed?: boolean;
-		error_message?: string;
-	};
-
+	const { project_id, build_passed, tests_passed, error_message } = parseArgs(args, reportValidationSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (build_passed === undefined) {
-		throw new ValidationError('build_passed is required', {
-			field: 'build_passed',
-			hint: 'Set to true if the build succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.reportValidation(project_id, {
 		build_passed,
@@ -115,10 +195,7 @@ export const reportValidation: Handler = async (args, ctx) => {
 };
 
 export const checkDeploymentStatus: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDeploymentStatusSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDeploymentStatus(project_id);
@@ -131,12 +208,9 @@ export const checkDeploymentStatus: Handler = async (args, ctx) => {
 };
 
 export const startDeployment: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id } = parseArgs(args, startDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.startDeployment(
 		project_id,
@@ -151,23 +225,9 @@ export const startDeployment: Handler = async (args, ctx) => {
 };
 
 export const completeDeployment: Handler = async (args, ctx) => {
-	const { project_id, success, summary } = args as {
-		project_id: string;
-		success: boolean;
-		summary?: string;
-	};
-
+	const { project_id, success, summary } = parseArgs(args, completeDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	if (success === undefined) {
-		throw new ValidationError('success is required', {
-			field: 'success',
-			hint: 'Set to true if deployment succeeded, false otherwise',
-		});
-	}
-
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeployment(project_id, {
 		success,
@@ -182,10 +242,7 @@ export const completeDeployment: Handler = async (args, ctx) => {
 };
 
 export const cancelDeployment: Handler = async (args, ctx) => {
-	const { project_id, reason } = args as { project_id: string; reason?: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, reason } = parseArgs(args, cancelDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.cancelDeployment(project_id, reason);
@@ -198,31 +255,7 @@ export const cancelDeployment: Handler = async (args, ctx) => {
 };
 
 export const addDeploymentRequirement: Handler = async (args, ctx) => {
-	const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false, recurring = false } = args as {
-		project_id: string;
-		type: string;
-		title: string;
-		description?: string;
-		file_path?: string;
-		stage?: string;
-		blocking?: boolean;
-		recurring?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(type, 'type');
-	validateRequired(title, 'title');
-
-	const validTypes = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
-	if (!validTypes.includes(type)) {
-		throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`);
-	}
-
-	const validStages = ['preparation', 'deployment', 'verification'];
-	if (!validStages.includes(stage)) {
-		throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
-	}
+	const { project_id, type, title, description, file_path, stage, blocking, recurring } = parseArgs(args, addDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.addDeploymentRequirement(project_id, {
@@ -243,10 +276,7 @@ export const addDeploymentRequirement: Handler = async (args, ctx) => {
 };
 
 export const completeDeploymentRequirement: Handler = async (args, ctx) => {
-	const { requirement_id } = args as { requirement_id: string };
-
-	validateRequired(requirement_id, 'requirement_id');
-	validateUUID(requirement_id, 'requirement_id');
+	const { requirement_id } = parseArgs(args, completeDeploymentRequirementSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.completeDeploymentRequirement(requirement_id);
@@ -259,14 +289,7 @@ export const completeDeploymentRequirement: Handler = async (args, ctx) => {
 };
 
 export const getDeploymentRequirements: Handler = async (args, ctx) => {
-	const { project_id, status = 'pending', stage } = args as {
-		project_id: string;
-		status?: string;
-		stage?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, status, stage } = parseArgs(args, getDeploymentRequirementsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getDeploymentRequirements(project_id, {
@@ -288,42 +311,14 @@ export const getDeploymentRequirements: Handler = async (args, ctx) => {
 export const scheduleDeployment: Handler = async (args, ctx) => {
 	const {
 		project_id,
-		environment = 'production',
-		version_bump = 'patch',
-		schedule_type = 'once',
+		environment,
+		version_bump,
+		schedule_type,
 		scheduled_at,
-		auto_trigger = true,
+		auto_trigger,
 		notes,
 		git_ref,
-	} = args as {
-		project_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at: string;
-		auto_trigger?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
-	validateRequired(scheduled_at, 'scheduled_at');
-	validateEnvironment(environment);
-
-	if (!['patch', 'minor', 'major'].includes(version_bump)) {
-		throw new ValidationError('Invalid version_bump value', {
-			field: 'version_bump',
-			validValues: ['patch', 'minor', 'major'],
-		});
-	}
-
-	if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-		throw new ValidationError('Invalid schedule_type value', {
-			field: 'schedule_type',
-			validValues: ['once', 'daily', 'weekly', 'monthly'],
-		});
-	}
+	} = parseArgs(args, scheduleDeploymentSchema);
 
 	// Parse and validate scheduled_at
 	const scheduledDate = new Date(scheduled_at);
@@ -359,13 +354,7 @@ export const scheduleDeployment: Handler = async (args, ctx) => {
 };
 
 export const getScheduledDeployments: Handler = async (args, ctx) => {
-	const { project_id, include_disabled = false } = args as {
-		project_id: string;
-		include_disabled?: boolean;
-	};
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id, include_disabled } = parseArgs(args, getScheduledDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
@@ -388,41 +377,13 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 		enabled,
 		notes,
 		git_ref,
-	} = args as {
-		schedule_id: string;
-		environment?: string;
-		version_bump?: string;
-		schedule_type?: string;
-		scheduled_at?: string;
-		auto_trigger?: boolean;
-		enabled?: boolean;
-		notes?: string;
-		git_ref?: string;
-	};
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	} = parseArgs(args, updateScheduledDeploymentSchema);
 
 	const updates: Record<string, unknown> = {};
 
-	if (environment !== undefined) {
-		validateEnvironment(environment);
-		updates.environment = environment;
-	}
-
-	if (version_bump !== undefined) {
-		if (!['patch', 'minor', 'major'].includes(version_bump)) {
-			throw new ValidationError('Invalid version_bump value');
-		}
-		updates.version_bump = version_bump;
-	}
-
-	if (schedule_type !== undefined) {
-		if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-			throw new ValidationError('Invalid schedule_type value');
-		}
-		updates.schedule_type = schedule_type;
-	}
+	if (environment !== undefined) updates.environment = environment;
+	if (version_bump !== undefined) updates.version_bump = version_bump;
+	if (schedule_type !== undefined) updates.schedule_type = schedule_type;
 
 	if (scheduled_at !== undefined) {
 		const scheduledDate = new Date(scheduled_at);
@@ -461,10 +422,7 @@ export const updateScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const deleteScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
-
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
+	const { schedule_id } = parseArgs(args, deleteScheduledDeploymentSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.deleteScheduledDeployment(schedule_id);
@@ -477,12 +435,9 @@ export const deleteScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const triggerScheduledDeployment: Handler = async (args, ctx) => {
-	const { schedule_id } = args as { schedule_id: string };
+	const { schedule_id } = parseArgs(args, triggerScheduledDeploymentSchema);
 	const { session } = ctx;
 
-	validateRequired(schedule_id, 'schedule_id');
-	validateUUID(schedule_id, 'schedule_id');
-
 	const apiClient = getApiClient();
 	const response = await apiClient.triggerScheduledDeployment(
 		schedule_id,
@@ -497,10 +452,7 @@ export const triggerScheduledDeployment: Handler = async (args, ctx) => {
 };
 
 export const checkDueDeployments: Handler = async (args, ctx) => {
-	const { project_id } = args as { project_id: string };
-
-	validateRequired(project_id, 'project_id');
-	validateUUID(project_id, 'project_id');
+	const { project_id } = parseArgs(args, checkDueDeploymentsSchema);
 
 	const apiClient = getApiClient();
 	const response = await apiClient.checkDueDeployments(project_id);

package/src/handlers/discovery.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { discoverTools, getToolInfo } from './discovery.js';
 import { createMockContext } from './__test-utils__.js';
+import { ValidationError } from '../validators.js';
 
 // ============================================================================
 // discoverTools Tests
@@ -113,13 +114,11 @@ describe('discoverTools', () => {
 // ============================================================================
 
 describe('getToolInfo', () => {
-	it('should return error for missing tool_name', async () => {
+	it('should throw ValidationError for missing tool_name', async () => {
 		const ctx = createMockContext();
 
-		const result = await getToolInfo({}, ctx);
-		const res = result.result as { error: string };
-
-		expect(res.error).toBe('tool_name is required');
+		await expect(getToolInfo({}, ctx)).rejects.toThrow(ValidationError);
+		await expect(getToolInfo({}, ctx)).rejects.toThrow('Missing required field: tool_name');
 	});
 
 	it('should return error for unknown tool', async () => {

package/src/handlers/discovery.ts

@@ -10,6 +10,16 @@
  */
 
 import type { Handler, HandlerRegistry } from './types.js';
+import { parseArgs } from '../validators.js';
+
+// Argument schemas for type-safe parsing
+const discoverToolsSchema = {
+	category: { type: 'string' as const },
+};
+
+const getToolInfoSchema = {
+	tool_name: { type: 'string' as const, required: true as const },
+};
 
 // Lazy-loaded tool documentation cache
 let toolInfoCache: Record<string, string> | null = null;
@@ -169,6 +179,22 @@ const TOOL_CATEGORIES: Record<string, { description: string; tools: Array<{ name
 			{ name: 'activate_body_of_work', brief: 'Activate for work' },
 		],
 	},
+	sprints: {
+		description: 'Time-bounded sprints with velocity tracking',
+		tools: [
+			{ name: 'create_sprint', brief: 'Create new sprint' },
+			{ name: 'update_sprint', brief: 'Update sprint details' },
+			{ name: 'get_sprint', brief: 'Get sprint with tasks' },
+			{ name: 'get_sprints', brief: 'List project sprints' },
+			{ name: 'delete_sprint', brief: 'Delete sprint' },
+			{ name: 'start_sprint', brief: 'Start sprint' },
+			{ name: 'complete_sprint', brief: 'Complete sprint' },
+			{ name: 'add_task_to_sprint', brief: 'Add task to sprint' },
+			{ name: 'remove_task_from_sprint', brief: 'Remove from sprint' },
+			{ name: 'get_sprint_backlog', brief: 'Get available tasks' },
+			{ name: 'get_sprint_velocity', brief: 'Velocity metrics' },
+		],
+	},
 	requests: {
 		description: 'User request handling',
 		tools: [
@@ -206,6 +232,15 @@ const TOOL_CATEGORIES: Record<string, { description: string; tools: Array<{ name
 			{ name: 'get_task_costs', brief: 'Cost per task' },
 		],
 	},
+	git_issues: {
+		description: 'Git conflict and issue tracking',
+		tools: [
+			{ name: 'add_git_issue', brief: 'Record git issue' },
+			{ name: 'resolve_git_issue', brief: 'Mark resolved' },
+			{ name: 'get_git_issues', brief: 'List git issues' },
+			{ name: 'delete_git_issue', brief: 'Delete git issue' },
+		],
+	},
 	knowledge: {
 		description: 'Queryable knowledge base from project data',
 		tools: [
@@ -215,7 +250,7 @@ const TOOL_CATEGORIES: Record<string, { description: string; tools: Array<{ name
 };
 
 export const discoverTools: Handler = async (args) => {
-	const { category } = args as { category?: string };
+	const { category } = parseArgs(args, discoverToolsSchema);
 
 	if (category) {
 		// Return tools in specific category
@@ -254,11 +289,7 @@ export const discoverTools: Handler = async (args) => {
 };
 
 export const getToolInfo: Handler = async (args) => {
-	const { tool_name } = args as { tool_name: string };
-
-	if (!tool_name) {
-		return { result: { error: 'tool_name is required' } };
-	}
+	const { tool_name } = parseArgs(args, getToolInfoSchema);
 
 	// Lazy-load tool documentation
 	const toolDocs = await getToolDocs();