@vibescope/mcp-server 0.2.2 → 0.2.4

package/src/handlers/progress.ts

@@ -22,7 +22,7 @@ const logProgressSchema = {
 
 const getActivityFeedSchema = {
 	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
-	limit: { type: 'number' as const, default: 50 },
+	limit: { type: 'number' as const, default: 10 },
 	since: { type: 'string' as const },
 	types: { type: 'array' as const },
 	created_by: { type: 'string' as const },
@@ -52,7 +52,7 @@ export const getActivityFeed: Handler = async (args, _ctx) => {
 	const { project_id, limit, since, types, created_by } = parseArgs(args, getActivityFeedSchema);
 
 	const apiClient = getApiClient();
-	const effectiveLimit = Math.min(limit ?? 50, 200);
+	const effectiveLimit = Math.min(limit ?? 10, 200);
 
 	const response = await apiClient.getActivityFeed(project_id, {
 		limit: effectiveLimit,

package/src/handlers/project.ts

@@ -55,6 +55,15 @@ const updateProjectSchema = {
 	git_auto_branch: { type: 'boolean' as const },
 	git_auto_tag: { type: 'boolean' as const },
 	deployment_instructions: { type: 'string' as const },
+	// New project settings
+	git_delete_branch_on_merge: { type: 'boolean' as const },
+	require_pr_for_validation: { type: 'boolean' as const },
+	auto_merge_on_approval: { type: 'boolean' as const },
+	validation_required: { type: 'boolean' as const },
+	default_task_priority: { type: 'number' as const },
+	require_time_estimates: { type: 'boolean' as const },
+	fallback_activities_enabled: { type: 'boolean' as const },
+	preferred_fallback_activities: { type: 'array' as const },
 };
 
 const updateProjectReadmeSchema = {
@@ -62,6 +71,10 @@ const updateProjectReadmeSchema = {
 	readme_content: { type: 'string' as const, required: true as const },
 };
 
+const getProjectSummarySchema = {
+	project_id: { type: 'string' as const, required: true as const, validate: uuidValidator },
+};
+
 export const getProjectContext: Handler = async (args, _ctx) => {
 	const { project_id, git_url } = parseArgs(args, getProjectContextSchema);
 
@@ -143,7 +156,16 @@ export const updateProject: Handler = async (args, _ctx) => {
 		git_develop_branch,
 		git_auto_branch,
 		git_auto_tag,
-		deployment_instructions
+		deployment_instructions,
+		// New project settings
+		git_delete_branch_on_merge,
+		require_pr_for_validation,
+		auto_merge_on_approval,
+		validation_required,
+		default_task_priority,
+		require_time_estimates,
+		fallback_activities_enabled,
+		preferred_fallback_activities
 	} = parseArgs(args, updateProjectSchema);
 
 	const apiClient = getApiClient();
@@ -159,7 +181,16 @@ export const updateProject: Handler = async (args, _ctx) => {
 		git_develop_branch,
 		git_auto_branch,
 		git_auto_tag,
-		deployment_instructions
+		deployment_instructions,
+		// New project settings
+		git_delete_branch_on_merge,
+		require_pr_for_validation,
+		auto_merge_on_approval,
+		validation_required,
+		default_task_priority,
+		require_time_estimates,
+		fallback_activities_enabled,
+		preferred_fallback_activities: preferred_fallback_activities as string[] | undefined
 	});
 
 	if (!response.ok) {
@@ -182,6 +213,19 @@ export const updateProjectReadme: Handler = async (args, _ctx) => {
 	return { result: response.data };
 };
 
+export const getProjectSummary: Handler = async (args, _ctx) => {
+	const { project_id } = parseArgs(args, getProjectSummarySchema);
+
+	const apiClient = getApiClient();
+	const response = await apiClient.getProjectSummary(project_id);
+
+	if (!response.ok) {
+		return { result: { error: response.error || 'Failed to get project summary' }, isError: true };
+	}
+
+	return { result: response.data };
+};
+
 /**
  * Project handlers registry
  */
@@ -191,4 +235,5 @@ export const projectHandlers: HandlerRegistry = {
 	create_project: createProject,
 	update_project: updateProject,
 	update_project_readme: updateProjectReadme,
+	get_project_summary: getProjectSummary,
 };

package/src/handlers/requests.test.ts

@@ -28,7 +28,7 @@ describe('getPendingRequests', () => {
 	it('should return empty list when no requests', async () => {
 		mockApiClient.getPendingRequests.mockResolvedValue({
 			ok: true,
-			data: { requests: [] },
+			data: { requests: [], total_count: 0, has_more: false },
 		});
 		const ctx = createMockContext();
 
@@ -39,11 +39,12 @@ describe('getPendingRequests', () => {
 
 		expect(result.result).toMatchObject({
 			requests: [],
-			count: 0,
+			total_count: 0,
+			has_more: false,
 		});
 	});
 
-	it('should return pending requests', async () => {
+	it('should return pending requests with pagination info', async () => {
 		const mockRequests = [
 			{
 				id: 'r1',
@@ -57,7 +58,7 @@ describe('getPendingRequests', () => {
 
 		mockApiClient.getPendingRequests.mockResolvedValue({
 			ok: true,
-			data: { requests: mockRequests },
+			data: { requests: mockRequests, total_count: 5, has_more: true },
 		});
 		const ctx = createMockContext();
 
@@ -66,13 +67,17 @@ describe('getPendingRequests', () => {
 			ctx
 		);
 
-		expect((result.result as { count: number }).count).toBe(1);
+		expect(result.result).toMatchObject({
+			requests: mockRequests,
+			total_count: 5,
+			has_more: true,
+		});
 	});
 
 	it('should call API client with project_id and session_id', async () => {
 		mockApiClient.getPendingRequests.mockResolvedValue({
 			ok: true,
-			data: { requests: [] },
+			data: { requests: [], total_count: 0, has_more: false },
 		});
 		const ctx = createMockContext({ sessionId: 'my-session' });
 
@@ -83,7 +88,33 @@ describe('getPendingRequests', () => {
 
 		expect(mockApiClient.getPendingRequests).toHaveBeenCalledWith(
 			'123e4567-e89b-12d3-a456-426614174000',
-			'my-session'
+			'my-session',
+			50,
+			0
+		);
+	});
+
+	it('should pass limit and offset to API client', async () => {
+		mockApiClient.getPendingRequests.mockResolvedValue({
+			ok: true,
+			data: { requests: [], total_count: 100, has_more: true },
+		});
+		const ctx = createMockContext({ sessionId: 'my-session' });
+
+		await getPendingRequests(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				limit: 10,
+				offset: 20,
+			},
+			ctx
+		);
+
+		expect(mockApiClient.getPendingRequests).toHaveBeenCalledWith(
+			'123e4567-e89b-12d3-a456-426614174000',
+			'my-session',
+			10,
+			20
 		);
 	});
 

package/src/handlers/requests.ts

@@ -16,6 +16,8 @@ import { getApiClient } from '../api-client.js';
 // Argument schemas for type-safe parsing
 const getPendingRequestsSchema = {
 	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 },
 };
 
 const acknowledgeRequestSchema = {
@@ -28,12 +30,12 @@ const answerQuestionSchema = {
 };
 
 export const getPendingRequests: Handler = async (args, ctx) => {
-	const { project_id } = parseArgs(args, getPendingRequestsSchema);
+	const { project_id, limit, offset } = parseArgs(args, getPendingRequestsSchema);
 
 	const { session } = ctx;
 	const apiClient = getApiClient();
 
-	const response = await apiClient.getPendingRequests(project_id, session.currentSessionId || undefined);
+	const response = await apiClient.getPendingRequests(project_id, session.currentSessionId || undefined, Math.min(limit ?? 50, 50), offset);
 
 	if (!response.ok) {
 		return { result: { error: response.error || 'Failed to get pending requests' }, isError: true };
@@ -42,7 +44,8 @@ export const getPendingRequests: Handler = async (args, ctx) => {
 	return {
 		result: {
 			requests: response.data?.requests || [],
-			count: response.data?.requests?.length || 0,
+			total_count: response.data?.total_count || 0,
+			has_more: response.data?.has_more || false,
 		},
 	};
 };

package/src/handlers/roles.test.ts

@@ -280,7 +280,7 @@ describe('getAgentsByRole', () => {
 		});
 		expect(mockApiClient.proxy).toHaveBeenCalledWith(
 			'get_agents_by_role',
-			{ project_id: '123e4567-e89b-12d3-a456-426614174000' }
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000', counts_only: true }
 		);
 	});
 

package/src/handlers/roles.ts

@@ -167,7 +167,7 @@ export const setSessionRole: Handler = async (args, ctx) => {
 };
 
 export const getAgentsByRole: Handler = async (args, _ctx) => {
-	const { project_id } = args as { project_id: string };
+	const { project_id, counts_only = true } = args as { project_id: string; counts_only?: boolean };
 
 	if (!project_id) {
 		return {
@@ -176,6 +176,24 @@ export const getAgentsByRole: Handler = async (args, _ctx) => {
 	}
 
 	const apiClient = getApiClient();
+
+	// Type varies based on counts_only
+	if (counts_only) {
+		const response = await apiClient.proxy<{
+			agents_by_role: Record<AgentRole, number>;
+			total_active: number;
+		}>('get_agents_by_role', { project_id, counts_only: true });
+
+		if (!response.ok) {
+			return {
+				result: { error: response.error || 'Failed to get agents by role' },
+			};
+		}
+
+		return { result: response.data };
+	}
+
+	// Full details mode
 	const response = await apiClient.proxy<{
 		agents_by_role: Record<AgentRole, Array<{
 			session_id: string;
@@ -186,7 +204,7 @@ export const getAgentsByRole: Handler = async (args, _ctx) => {
 			last_synced_at: string;
 		}>>;
 		total_active: number;
-	}>('get_agents_by_role', { project_id });
+	}>('get_agents_by_role', { project_id, counts_only: false });
 
 	if (!response.ok) {
 		return {

package/src/handlers/session.test.ts

@@ -5,6 +5,7 @@ import {
 	endWorkSession,
 	getHelp,
 	getTokenUsage,
+	reportTokenUsage,
 } from './session.js';
 import { createMockContext } from './__test-utils__.js';
 import { mockApiClient } from './__test-setup__.js';
@@ -31,7 +32,7 @@ describe('heartbeat', () => {
 			session_id: 'session-123',
 		});
 		expect(result.result).toHaveProperty('timestamp');
-		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', { current_worktree_path: undefined });
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', expect.objectContaining({ current_worktree_path: undefined }));
 	});
 
 	it('should use provided session_id over current session', async () => {
@@ -48,7 +49,7 @@ describe('heartbeat', () => {
 			success: true,
 			session_id: 'other-session-456',
 		});
-		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('other-session-456', { current_worktree_path: undefined });
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('other-session-456', expect.objectContaining({ current_worktree_path: undefined }));
 	});
 
 	it('should pass worktree_path to API', async () => {
@@ -61,7 +62,7 @@ describe('heartbeat', () => {
 
 		await heartbeat({ current_worktree_path: '../project-task-abc123' }, ctx);
 
-		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', { current_worktree_path: '../project-task-abc123' });
+		expect(mockApiClient.heartbeat).toHaveBeenCalledWith('session-123', expect.objectContaining({ current_worktree_path: '../project-task-abc123' }));
 	});
 
 	it('should return error when no active session', async () => {
@@ -80,7 +81,7 @@ describe('heartbeat', () => {
 				callCount: 10,
 				totalTokens: 5000,
 				byTool: {
-					get_tasks: { calls: 3, tokens: 1500 },
+					get_task: { calls: 3, tokens: 1500 },
 					update_task: { calls: 4, tokens: 2000 },
 					complete_task: { calls: 3, tokens: 1500 },
 				},
@@ -573,4 +574,302 @@ describe('startWorkSession', () => {
 		expect(result.result).not.toHaveProperty('pending_requests');
 		expect(result.result).not.toHaveProperty('pending_requests_count');
 	});
+
+	it('should surface awaiting_validation tasks when present', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		const mockValidationTasks = [
+			{ id: 'task-1', title: 'Implement login' },
+			{ id: 'task-2', title: 'Add tests' },
+		];
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'new-session-123',
+				persona: 'Wave',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+				awaiting_validation: mockValidationTasks,
+				validation_count: 2,
+				validation_priority: 'VALIDATE FIRST: 2 task(s) need review before starting new work.',
+				directive: 'VALIDATE FIRST: 2 task(s) need review before starting new work. Call claim_validation(task_id) to start reviewing.',
+			},
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toHaveProperty('awaiting_validation');
+		expect(result.result).toHaveProperty('validation_count', 2);
+		expect(result.result).toHaveProperty('validation_priority');
+		const awaitingValidation = (result.result as { awaiting_validation: typeof mockValidationTasks }).awaiting_validation;
+		expect(awaitingValidation.length).toBe(2);
+		expect(awaitingValidation[0].id).toBe('task-1');
+	});
+
+	it('should include next_action when validation tasks are present', async () => {
+		const ctx = createMockContext({ sessionId: null });
+		mockApiClient.startSession.mockResolvedValue({
+			ok: true,
+			data: {
+				session_started: true,
+				session_id: 'new-session-123',
+				persona: 'Wave',
+				role: 'developer',
+				project: { id: 'project-123', name: 'Test Project' },
+				awaiting_validation: [{ id: 'task-abc', title: 'Fix bug' }],
+				validation_count: 1,
+				next_action: 'claim_validation(task_id: "task-abc")',
+			},
+		});
+
+		const result = await startWorkSession({ project_id: 'project-123' }, ctx);
+
+		expect(result.result).toHaveProperty('next_action');
+		expect((result.result as { next_action: string }).next_action).toContain('task-abc');
+	});
+});
+
+// ============================================================================
+// reportTokenUsage Tests
+// ============================================================================
+
+describe('reportTokenUsage', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should report token usage successfully with session', async () => {
+		const ctx = createMockContext();
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'sonnet',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0105,
+				},
+				task_attributed: true,
+				task_id: 'task-123',
+			},
+		});
+
+		const result = await reportTokenUsage(
+			{ input_tokens: 1000, output_tokens: 500, model: 'sonnet' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			task_attributed: true,
+			task_id: 'task-123',
+		});
+		expect(result.result).toHaveProperty('reported');
+		expect(mockApiClient.reportTokenUsage).toHaveBeenCalledWith('session-123', {
+			input_tokens: 1000,
+			output_tokens: 500,
+			model: 'sonnet',
+		});
+	});
+
+	it('should default to sonnet model when not specified', async () => {
+		const ctx = createMockContext();
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'sonnet',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0105,
+				},
+				task_attributed: false,
+			},
+		});
+
+		await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		expect(mockApiClient.reportTokenUsage).toHaveBeenCalledWith('session-123', {
+			input_tokens: 1000,
+			output_tokens: 500,
+			model: 'sonnet',
+		});
+	});
+
+	it('should use session currentModel if available', async () => {
+		const ctx = createMockContext({
+			tokenUsage: {
+				callCount: 0,
+				totalTokens: 0,
+				byTool: {},
+				byModel: {},
+				currentModel: 'opus',
+			},
+		});
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'opus',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0525,
+				},
+				task_attributed: false,
+			},
+		});
+
+		await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		expect(mockApiClient.reportTokenUsage).toHaveBeenCalledWith('session-123', {
+			input_tokens: 1000,
+			output_tokens: 500,
+			model: 'opus',
+		});
+	});
+
+	it('should return error for negative token counts', async () => {
+		const ctx = createMockContext();
+
+		const result = await reportTokenUsage({ input_tokens: -100, output_tokens: 500 }, ctx);
+
+		expect(result.result).toMatchObject({
+			error: 'Token counts must be non-negative',
+		});
+		expect(mockApiClient.reportTokenUsage).not.toHaveBeenCalled();
+	});
+
+	it('should handle local-only reporting when no session', async () => {
+		const ctx = createMockContext({ sessionId: null });
+
+		const result = await reportTokenUsage(
+			{ input_tokens: 1000, output_tokens: 500, model: 'haiku' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+		expect(result.result).toHaveProperty('reported');
+		const reported = (result.result as { reported: { model: string } }).reported;
+		expect(reported.model).toBe('haiku');
+		expect(result.result).toHaveProperty('note');
+		expect(mockApiClient.reportTokenUsage).not.toHaveBeenCalled();
+	});
+
+	it('should update local token tracking', async () => {
+		const ctx = createMockContext({
+			tokenUsage: {
+				callCount: 5,
+				totalTokens: 2500,
+				byTool: {},
+				byModel: { sonnet: { input: 1000, output: 500 } },
+				currentModel: null,
+			},
+		});
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'sonnet',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0105,
+				},
+				task_attributed: false,
+			},
+		});
+
+		await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		expect(ctx.updateSession).toHaveBeenCalledWith(
+			expect.objectContaining({
+				tokenUsage: expect.objectContaining({
+					callCount: 6,
+					totalTokens: 4000,
+					byModel: { sonnet: { input: 2000, output: 1000 } },
+				}),
+			})
+		);
+	});
+
+	it('should handle backend failure gracefully', async () => {
+		const ctx = createMockContext();
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: false,
+			error: 'Server error',
+		});
+
+		const result = await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		// Should still succeed with local calculation
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+		expect(result.result).toHaveProperty('warning');
+	});
+
+	it('should indicate when task attribution succeeds', async () => {
+		const ctx = createMockContext();
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'sonnet',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0105,
+				},
+				task_attributed: true,
+				task_id: 'task-abc123',
+			},
+		});
+
+		const result = await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		expect(result.result).toMatchObject({
+			task_attributed: true,
+			task_id: 'task-abc123',
+		});
+		expect((result.result as { note: string }).note).toContain('attributed to current task');
+	});
+
+	it('should indicate when no task to attribute to', async () => {
+		const ctx = createMockContext();
+		mockApiClient.reportTokenUsage.mockResolvedValue({
+			ok: true,
+			data: {
+				success: true,
+				reported: {
+					session_id: 'session-123',
+					model: 'sonnet',
+					input_tokens: 1000,
+					output_tokens: 500,
+					total_tokens: 1500,
+					estimated_cost_usd: 0.0105,
+				},
+				task_attributed: false,
+			},
+		});
+
+		const result = await reportTokenUsage({ input_tokens: 1000, output_tokens: 500 }, ctx);
+
+		expect(result.result).toMatchObject({
+			task_attributed: false,
+		});
+		expect((result.result as { note: string }).note).toContain('No active task');
+	});
 });