@vibescope/mcp-server 0.0.1

package/src/handlers/cost.ts

@@ -0,0 +1,322 @@
+/**
+ * Cost Handlers
+ *
+ * Handles cost monitoring and alerts:
+ * - get_cost_summary
+ * - get_cost_alerts
+ * - add_cost_alert
+ * - update_cost_alert
+ * - delete_cost_alert
+ */
+
+import type { Handler, HandlerRegistry } from './types.js';
+
+/**
+ * Get cost summary for a project (daily, weekly, or monthly)
+ */
+export const getCostSummary: Handler = async (args, ctx) => {
+	const { project_id, period = 'daily', limit = 30 } = args as {
+		project_id: string;
+		period?: 'daily' | 'weekly' | 'monthly';
+		limit?: number;
+	};
+
+	const { supabase } = ctx;
+
+	if (!project_id) {
+		return {
+			result: { error: 'project_id is required' },
+			isError: true,
+		};
+	}
+
+	// Select the appropriate view based on period
+	const viewName = `${period}_cost_summary`;
+
+	const { data, error } = await supabase
+		.from(viewName)
+		.select('*')
+		.eq('project_id', project_id)
+		.order(period === 'daily' ? 'date' : period === 'weekly' ? 'week_start' : 'month_start', { ascending: false })
+		.limit(limit);
+
+	if (error) {
+		return {
+			result: { error: `Failed to get cost summary: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	// Calculate totals
+	const totals = (data || []).reduce(
+		(acc, row) => ({
+			sessions: acc.sessions + (row.session_count || 0),
+			tokens: acc.tokens + (row.total_tokens || 0),
+			calls: acc.calls + (row.total_calls || 0),
+			cost: acc.cost + parseFloat(row.estimated_cost_usd || '0'),
+		}),
+		{ sessions: 0, tokens: 0, calls: 0, cost: 0 }
+	);
+
+	return {
+		result: {
+			period,
+			project_id,
+			summary: data || [],
+			totals: {
+				...totals,
+				cost: Math.round(totals.cost * 100) / 100,
+			},
+		},
+	};
+};
+
+/**
+ * Get cost alerts for the current user
+ */
+export const getCostAlerts: Handler = async (args, ctx) => {
+	const { project_id } = args as { project_id?: string };
+	const { supabase, auth } = ctx;
+
+	let query = supabase
+		.from('cost_alerts')
+		.select('*')
+		.eq('user_id', auth.userId)
+		.order('threshold_amount', { ascending: true });
+
+	if (project_id) {
+		query = query.eq('project_id', project_id);
+	}
+
+	const { data, error } = await query;
+
+	if (error) {
+		return {
+			result: { error: `Failed to get cost alerts: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	return {
+		result: {
+			alerts: data || [],
+			count: data?.length || 0,
+		},
+	};
+};
+
+/**
+ * Add a cost alert
+ */
+export const addCostAlert: Handler = async (args, ctx) => {
+	const {
+		project_id,
+		threshold_amount,
+		threshold_period,
+		alert_type = 'warning',
+	} = args as {
+		project_id?: string;
+		threshold_amount: number;
+		threshold_period: 'daily' | 'weekly' | 'monthly';
+		alert_type?: 'warning' | 'critical';
+	};
+
+	const { supabase, auth } = ctx;
+
+	if (!threshold_amount || threshold_amount <= 0) {
+		return {
+			result: { error: 'threshold_amount must be a positive number' },
+			isError: true,
+		};
+	}
+
+	if (!threshold_period || !['daily', 'weekly', 'monthly'].includes(threshold_period)) {
+		return {
+			result: { error: 'threshold_period must be "daily", "weekly", or "monthly"' },
+			isError: true,
+		};
+	}
+
+	const { data, error } = await supabase
+		.from('cost_alerts')
+		.insert({
+			user_id: auth.userId,
+			project_id: project_id || null,
+			threshold_amount,
+			threshold_period,
+			alert_type,
+		})
+		.select()
+		.single();
+
+	if (error) {
+		return {
+			result: { error: `Failed to create cost alert: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	return {
+		result: {
+			success: true,
+			alert: data,
+			message: `Alert created: ${alert_type} when ${threshold_period} cost exceeds $${threshold_amount}`,
+		},
+	};
+};
+
+/**
+ * Update a cost alert
+ */
+export const updateCostAlert: Handler = async (args, ctx) => {
+	const {
+		alert_id,
+		threshold_amount,
+		threshold_period,
+		alert_type,
+		enabled,
+	} = args as {
+		alert_id: string;
+		threshold_amount?: number;
+		threshold_period?: 'daily' | 'weekly' | 'monthly';
+		alert_type?: 'warning' | 'critical';
+		enabled?: boolean;
+	};
+
+	const { supabase, auth } = ctx;
+
+	if (!alert_id) {
+		return {
+			result: { error: 'alert_id is required' },
+			isError: true,
+		};
+	}
+
+	const updates: Record<string, unknown> = {};
+	if (threshold_amount !== undefined) updates.threshold_amount = threshold_amount;
+	if (threshold_period !== undefined) updates.threshold_period = threshold_period;
+	if (alert_type !== undefined) updates.alert_type = alert_type;
+	if (enabled !== undefined) updates.enabled = enabled;
+
+	if (Object.keys(updates).length === 0) {
+		return {
+			result: { error: 'No updates provided' },
+			isError: true,
+		};
+	}
+
+	const { data, error } = await supabase
+		.from('cost_alerts')
+		.update(updates)
+		.eq('id', alert_id)
+		.eq('user_id', auth.userId)
+		.select()
+		.single();
+
+	if (error) {
+		return {
+			result: { error: `Failed to update cost alert: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	return {
+		result: {
+			success: true,
+			alert: data,
+		},
+	};
+};
+
+/**
+ * Delete a cost alert
+ */
+export const deleteCostAlert: Handler = async (args, ctx) => {
+	const { alert_id } = args as { alert_id: string };
+	const { supabase, auth } = ctx;
+
+	if (!alert_id) {
+		return {
+			result: { error: 'alert_id is required' },
+			isError: true,
+		};
+	}
+
+	const { error } = await supabase
+		.from('cost_alerts')
+		.delete()
+		.eq('id', alert_id)
+		.eq('user_id', auth.userId);
+
+	if (error) {
+		return {
+			result: { error: `Failed to delete cost alert: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	return {
+		result: {
+			success: true,
+			deleted_alert_id: alert_id,
+		},
+	};
+};
+
+/**
+ * Get task costs for a project
+ */
+export const getTaskCosts: Handler = async (args, ctx) => {
+	const { project_id, limit = 20 } = args as {
+		project_id: string;
+		limit?: number;
+	};
+
+	const { supabase } = ctx;
+
+	if (!project_id) {
+		return {
+			result: { error: 'project_id is required' },
+			isError: true,
+		};
+	}
+
+	const { data, error } = await supabase
+		.from('task_costs')
+		.select('*')
+		.eq('project_id', project_id)
+		.order('estimated_cost_usd', { ascending: false })
+		.limit(limit);
+
+	if (error) {
+		return {
+			result: { error: `Failed to get task costs: ${error.message}` },
+			isError: true,
+		};
+	}
+
+	const totalCost = (data || []).reduce(
+		(sum, task) => sum + parseFloat(task.estimated_cost_usd || '0'),
+		0
+	);
+
+	return {
+		result: {
+			project_id,
+			tasks: data || [],
+			total_cost_usd: Math.round(totalCost * 100) / 100,
+		},
+	};
+};
+
+/**
+ * Cost handlers registry
+ */
+export const costHandlers: HandlerRegistry = {
+	get_cost_summary: getCostSummary,
+	get_cost_alerts: getCostAlerts,
+	add_cost_alert: addCostAlert,
+	update_cost_alert: updateCostAlert,
+	delete_cost_alert: deleteCostAlert,
+	get_task_costs: getTaskCosts,
+};

package/src/handlers/decisions.test.ts

@@ -0,0 +1,401 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { HandlerContext, TokenUsage } from './types.js';
+import { logDecision, getDecisions, deleteDecision } from './decisions.js';
+import { ValidationError } from '../validators.js';
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+function createMockSupabase(overrides: {
+	selectResult?: { data: unknown; error: unknown };
+	insertResult?: { data: unknown; error: unknown };
+	deleteResult?: { data: unknown; error: unknown };
+} = {}) {
+	const defaultResult = { data: null, error: null };
+	let currentOperation = 'select';
+	let insertThenSelect = false;
+
+	const mock = {
+		from: vi.fn().mockReturnThis(),
+		select: vi.fn(() => {
+			if (currentOperation === 'insert') {
+				insertThenSelect = true;
+			} else {
+				currentOperation = 'select';
+				insertThenSelect = false;
+			}
+			return mock;
+		}),
+		insert: vi.fn(() => {
+			currentOperation = 'insert';
+			insertThenSelect = false;
+			return mock;
+		}),
+		delete: vi.fn(() => {
+			currentOperation = 'delete';
+			insertThenSelect = false;
+			return mock;
+		}),
+		eq: vi.fn().mockReturnThis(),
+		order: vi.fn().mockReturnThis(),
+		single: vi.fn(() => {
+			if (currentOperation === 'insert' || insertThenSelect) {
+				return Promise.resolve(overrides.insertResult ?? defaultResult);
+			}
+			if (currentOperation === 'select') {
+				return Promise.resolve(overrides.selectResult ?? defaultResult);
+			}
+			return Promise.resolve(defaultResult);
+		}),
+		then: vi.fn((resolve: (value: unknown) => void) => {
+			if (currentOperation === 'insert' || insertThenSelect) {
+				return Promise.resolve(overrides.insertResult ?? defaultResult).then(resolve);
+			}
+			if (currentOperation === 'select') {
+				return Promise.resolve(overrides.selectResult ?? defaultResult).then(resolve);
+			}
+			if (currentOperation === 'delete') {
+				return Promise.resolve(overrides.deleteResult ?? defaultResult).then(resolve);
+			}
+			return Promise.resolve(defaultResult).then(resolve);
+		}),
+	};
+
+	return mock as unknown as SupabaseClient;
+}
+
+function createMockContext(
+	supabase: SupabaseClient,
+	options: { sessionId?: string | null } = {}
+): HandlerContext {
+	const defaultTokenUsage: TokenUsage = {
+		callCount: 5,
+		totalTokens: 2500,
+		byTool: {},
+	};
+
+	const sessionId = 'sessionId' in options ? options.sessionId : 'session-123';
+
+	return {
+		supabase,
+		auth: { userId: 'user-123', apiKeyId: 'api-key-123' },
+		session: {
+			instanceId: 'instance-abc',
+			currentSessionId: sessionId,
+			currentPersona: 'Wave',
+			tokenUsage: defaultTokenUsage,
+		},
+		updateSession: vi.fn(),
+	};
+}
+
+// ============================================================================
+// logDecision Tests
+// ============================================================================
+
+describe('logDecision', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logDecision({ title: 'Decision', description: 'Description' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logDecision({ project_id: 'invalid', title: 'Decision', description: 'Description' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing title', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', description: 'Description' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for missing description', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logDecision({ project_id: '123e4567-e89b-12d3-a456-426614174000', title: 'Decision' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should log decision successfully', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await logDecision(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Use PostgreSQL',
+				description: 'Decided to use PostgreSQL for the database',
+			},
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+			title: 'Use PostgreSQL',
+		});
+	});
+
+	it('should log decision with rationale and alternatives', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await logDecision(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Use PostgreSQL',
+				description: 'Decided to use PostgreSQL for the database',
+				rationale: 'Better JSON support and reliability',
+				alternatives_considered: ['MySQL', 'MongoDB'],
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				title: 'Use PostgreSQL',
+				description: 'Decided to use PostgreSQL for the database',
+				rationale: 'Better JSON support and reliability',
+				alternatives_considered: ['MySQL', 'MongoDB'],
+				created_by: 'agent',
+				created_by_session_id: 'session-123',
+			})
+		);
+	});
+
+	it('should include session_id in insert', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase, { sessionId: 'my-session' });
+
+		await logDecision(
+			{
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Decision',
+				description: 'Description',
+			},
+			ctx
+		);
+
+		expect(supabase.insert).toHaveBeenCalledWith(
+			expect.objectContaining({
+				created_by: 'agent',
+				created_by_session_id: 'my-session',
+			})
+		);
+	});
+
+	it('should throw error when insert fails', async () => {
+		const supabase = createMockSupabase({
+			insertResult: { data: null, error: { message: 'Insert failed' } },
+		});
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			logDecision({
+				project_id: '123e4567-e89b-12d3-a456-426614174000',
+				title: 'Decision',
+				description: 'Description',
+			}, ctx)
+		).rejects.toThrow('Failed to log decision: Insert failed');
+	});
+});
+
+// ============================================================================
+// getDecisions Tests
+// ============================================================================
+
+describe('getDecisions', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing project_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(getDecisions({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid project_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			getDecisions({ project_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should return empty list when no decisions', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getDecisions(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			decisions: [],
+		});
+	});
+
+	it('should return decisions list', async () => {
+		const mockDecisions = [
+			{ id: 'd1', title: 'Decision 1', description: 'Desc 1', created_at: '2025-01-14T10:00:00Z' },
+			{ id: 'd2', title: 'Decision 2', description: 'Desc 2', created_at: '2025-01-14T11:00:00Z' },
+		];
+
+		const supabase = createMockSupabase({
+			selectResult: { data: mockDecisions, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await getDecisions(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect((result.result as { decisions: unknown[] }).decisions).toHaveLength(2);
+	});
+
+	it('should query decisions table', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getDecisions(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('decisions');
+	});
+
+	it('should order by created_at descending', async () => {
+		const supabase = createMockSupabase({
+			selectResult: { data: [], error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await getDecisions(
+			{ project_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.order).toHaveBeenCalledWith('created_at', { ascending: false });
+	});
+
+	it('should throw error when query fails', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		// Override to return error
+		vi.mocked(supabase.from('').select).mockReturnValue({
+			...supabase,
+			then: (resolve: (val: unknown) => void) =>
+				Promise.resolve({ data: null, error: { message: 'Query failed' } }).then(resolve),
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		await expect(
+			getDecisions({ project_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to fetch decisions');
+	});
+});
+
+// ============================================================================
+// deleteDecision Tests
+// ============================================================================
+
+describe('deleteDecision', () => {
+	beforeEach(() => vi.clearAllMocks());
+
+	it('should throw error for missing decision_id', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(deleteDecision({}, ctx)).rejects.toThrow(ValidationError);
+	});
+
+	it('should throw error for invalid decision_id UUID', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		await expect(
+			deleteDecision({ decision_id: 'invalid' }, ctx)
+		).rejects.toThrow(ValidationError);
+	});
+
+	it('should delete decision successfully', async () => {
+		const supabase = createMockSupabase({
+			deleteResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		const result = await deleteDecision(
+			{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(result.result).toMatchObject({
+			success: true,
+		});
+	});
+
+	it('should call delete on decisions table', async () => {
+		const supabase = createMockSupabase({
+			deleteResult: { data: null, error: null },
+		});
+		const ctx = createMockContext(supabase);
+
+		await deleteDecision(
+			{ decision_id: '123e4567-e89b-12d3-a456-426614174000' },
+			ctx
+		);
+
+		expect(supabase.from).toHaveBeenCalledWith('decisions');
+		expect(supabase.delete).toHaveBeenCalled();
+		expect(supabase.eq).toHaveBeenCalledWith('id', '123e4567-e89b-12d3-a456-426614174000');
+	});
+
+	it('should throw error when delete fails', async () => {
+		const supabase = createMockSupabase();
+		const ctx = createMockContext(supabase);
+
+		// Override delete to return error
+		vi.mocked(supabase.from('').delete).mockReturnValue({
+			...supabase,
+			eq: vi.fn().mockReturnValue({
+				then: (resolve: (val: unknown) => void) =>
+					Promise.resolve({ data: null, error: { message: 'Delete failed' } }).then(resolve),
+			}),
+		} as unknown as ReturnType<SupabaseClient['from']>);
+
+		await expect(
+			deleteDecision({ decision_id: '123e4567-e89b-12d3-a456-426614174000' }, ctx)
+		).rejects.toThrow('Failed to delete decision');
+	});
+});