@vibescope/mcp-server 0.0.1

package/src/handlers/discovery.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { HandlerContext, TokenUsage } from './types.js';
+import { discoverTools, getToolInfo } from './discovery.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+function createMockSupabase() {
+	return {} as unknown as SupabaseClient;
+}
+
+function createMockContext(supabase: SupabaseClient): HandlerContext {
+	const defaultTokenUsage: TokenUsage = {
+		callCount: 5,
+		totalTokens: 2500,
+		byTool: {},
+	};
+
+	return {
+		supabase,
+		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
+		session: {
+			instanceId: 'instance-abc',
+			currentSessionId: 'session-123',
+			currentPersona: 'Wave',
+			tokenUsage: defaultTokenUsage,
+		},
+		updateSession: vi.fn(),
+	};
+}
+
+// ============================================================================
+// discoverTools Tests
+// ============================================================================
+
+describe('discoverTools', () => {
+	it('should return all categories when no category specified', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { categories: unknown[]; total_tools: number };
+
+		expect(res.categories).toBeDefined();
+		expect(Array.isArray(res.categories)).toBe(true);
+		expect(res.categories.length).toBeGreaterThan(0);
+		expect(res.total_tools).toBeGreaterThan(0);
+	});
+
+	it('should return category info with tool counts', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { categories: { name: string; description: string; tool_count: number }[] };
+
+		const category = res.categories[0];
+		expect(category.name).toBeDefined();
+		expect(category.description).toBeDefined();
+		expect(category.tool_count).toBeGreaterThan(0);
+	});
+
+	it('should return tools for specific category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({ category: 'session' }, ctx);
+		const res = result.result as { category: string; description: string; tools: unknown[] };
+
+		expect(res.category).toBe('session');
+		expect(res.description).toBeDefined();
+		expect(res.tools).toBeDefined();
+		expect(Array.isArray(res.tools)).toBe(true);
+	});
+
+	it('should return tools with name and brief for specific category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({ category: 'tasks' }, ctx);
+		const res = result.result as { tools: { name: string; brief: string }[] };
+
+		expect(res.tools.length).toBeGreaterThan(0);
+		const tool = res.tools[0];
+		expect(tool.name).toBeDefined();
+		expect(tool.brief).toBeDefined();
+	});
+
+	it('should return error for unknown category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({ category: 'nonexistent' }, ctx);
+		const res = result.result as { error: string; available: string[] };
+
+		expect(res.error).toContain('Unknown category');
+		expect(res.available).toBeDefined();
+		expect(Array.isArray(res.available)).toBe(true);
+	});
+
+	it('should include session category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { categories: { name: string }[] };
+
+		const categoryNames = res.categories.map((c) => c.name);
+		expect(categoryNames).toContain('session');
+	});
+
+	it('should include tasks category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { categories: { name: string }[] };
+
+		const categoryNames = res.categories.map((c) => c.name);
+		expect(categoryNames).toContain('tasks');
+	});
+
+	it('should include deployment category', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { categories: { name: string }[] };
+
+		const categoryNames = res.categories.map((c) => c.name);
+		expect(categoryNames).toContain('deployment');
+	});
+
+	it('should include usage hint in response', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await discoverTools({}, ctx);
+		const res = result.result as { usage: string };
+
+		expect(res.usage).toBeDefined();
+		expect(res.usage).toContain('discover_tools');
+		expect(res.usage).toContain('get_tool_info');
+	});
+});
+
+// ============================================================================
+// getToolInfo Tests
+// ============================================================================
+
+describe('getToolInfo', () => {
+	it('should return error for missing tool_name', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({}, ctx);
+		const res = result.result as { error: string };
+
+		expect(res.error).toBe('tool_name is required');
+	});
+
+	it('should return error for unknown tool', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'nonexistent_tool' }, ctx);
+		const res = result.result as { error: string; hint: string };
+
+		expect(res.error).toContain('Unknown tool');
+		expect(res.hint).toContain('discover_tools');
+	});
+
+	it('should return info for start_work_session', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'start_work_session' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('start_work_session');
+		expect(res.info).toBeDefined();
+		expect(res.info).toContain('start_work_session');
+	});
+
+	it('should return info for add_task', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'add_task' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('add_task');
+		expect(res.info).toBeDefined();
+		expect(res.info).toContain('task');
+	});
+
+	it('should return info for complete_task', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'complete_task' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('complete_task');
+		expect(res.info).toBeDefined();
+	});
+
+	it('should return info for request_deployment', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'request_deployment' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('request_deployment');
+		expect(res.info).toBeDefined();
+		expect(res.info).toContain('deployment');
+	});
+
+	it('should return info with parameters section', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'add_task' }, ctx);
+		const res = result.result as { info: string };
+
+		expect(res.info).toContain('Parameters');
+	});
+
+	it('should return info for get_help', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'get_help' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('get_help');
+		expect(res.info).toBeDefined();
+		expect(res.info).toContain('topic');
+	});
+
+	it('should return info for discover_tools', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		const result = await getToolInfo({ tool_name: 'discover_tools' }, ctx);
+		const res = result.result as { tool: string; info: string };
+
+		expect(res.tool).toBe('discover_tools');
+		expect(res.info).toBeDefined();
+	});
+});