@vibescope/mcp-server 0.0.1 → 0.2.0

package/dist/handlers/cost.d.ts

@@ -7,6 +7,7 @@
  * - add_cost_alert
  * - update_cost_alert
  * - delete_cost_alert
+ * - get_task_costs
  */
 import type { Handler, HandlerRegistry } from './types.js';
 /**

package/dist/handlers/cost.js

@@ -7,86 +7,50 @@
  * - add_cost_alert
  * - update_cost_alert
  * - delete_cost_alert
+ * - get_task_costs
  */
+import { getApiClient } from '../api-client.js';
 /**
  * Get cost summary for a project (daily, weekly, or monthly)
  */
 export const getCostSummary = async (args, ctx) => {
     const { project_id, period = 'daily', limit = 30 } = args;
-    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) {
+    const apiClient = getApiClient();
+    const response = await apiClient.getCostSummary(project_id, { period, limit });
+    if (!response.ok) {
         return {
-            result: { error: `Failed to get cost summary: ${error.message}` },
+            result: { error: response.error || 'Failed to get cost summary' },
             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,
-            },
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Get cost alerts for the current user
  */
 export const getCostAlerts = async (args, ctx) => {
     const { project_id } = args;
-    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) {
+    const apiClient = getApiClient();
+    const response = await apiClient.getCostAlerts();
+    if (!response.ok) {
         return {
-            result: { error: `Failed to get cost alerts: ${error.message}` },
+            result: { error: response.error || 'Failed to get cost alerts' },
             isError: true,
         };
     }
-    return {
-        result: {
-            alerts: data || [],
-            count: data?.length || 0,
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Add a cost alert
  */
 export const addCostAlert = async (args, ctx) => {
     const { project_id, threshold_amount, threshold_period, alert_type = 'warning', } = args;
-    const { supabase, auth } = ctx;
     if (!threshold_amount || threshold_amount <= 0) {
         return {
             result: { error: 'threshold_amount must be a positive number' },
@@ -99,37 +63,26 @@ export const addCostAlert = async (args, ctx) => {
             isError: true,
         };
     }
-    const { data, error } = await supabase
-        .from('cost_alerts')
-        .insert({
-        user_id: auth.userId,
-        project_id: project_id || null,
+    const apiClient = getApiClient();
+    const response = await apiClient.addCostAlert({
+        project_id,
         threshold_amount,
         threshold_period,
-        alert_type,
-    })
-        .select()
-        .single();
-    if (error) {
+        alert_type
+    });
+    if (!response.ok) {
         return {
-            result: { error: `Failed to create cost alert: ${error.message}` },
+            result: { error: response.error || 'Failed to create cost alert' },
             isError: true,
         };
     }
-    return {
-        result: {
-            success: true,
-            alert: data,
-            message: `Alert created: ${alert_type} when ${threshold_period} cost exceeds $${threshold_amount}`,
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Update a cost alert
  */
 export const updateCostAlert = async (args, ctx) => {
     const { alert_id, threshold_amount, threshold_period, alert_type, enabled, } = args;
-    const { supabase, auth } = ctx;
     if (!alert_id) {
         return {
             result: { error: 'alert_id is required' },
@@ -151,88 +104,57 @@ export const updateCostAlert = async (args, ctx) => {
             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) {
+    const apiClient = getApiClient();
+    const response = await apiClient.updateCostAlert(alert_id, updates);
+    if (!response.ok) {
         return {
-            result: { error: `Failed to update cost alert: ${error.message}` },
+            result: { error: response.error || 'Failed to update cost alert' },
             isError: true,
         };
     }
-    return {
-        result: {
-            success: true,
-            alert: data,
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Delete a cost alert
  */
 export const deleteCostAlert = async (args, ctx) => {
     const { alert_id } = args;
-    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) {
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteCostAlert(alert_id);
+    if (!response.ok) {
         return {
-            result: { error: `Failed to delete cost alert: ${error.message}` },
+            result: { error: response.error || 'Failed to delete cost alert' },
             isError: true,
         };
     }
-    return {
-        result: {
-            success: true,
-            deleted_alert_id: alert_id,
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Get task costs for a project
  */
 export const getTaskCosts = async (args, ctx) => {
     const { project_id, limit = 20 } = args;
-    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) {
+    const apiClient = getApiClient();
+    const response = await apiClient.getTaskCosts(project_id, limit);
+    if (!response.ok) {
         return {
-            result: { error: `Failed to get task costs: ${error.message}` },
+            result: { error: response.error || 'Failed to get task costs' },
             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,
-        },
-    };
+    return { result: response.data };
 };
 /**
  * Cost handlers registry

package/dist/handlers/decisions.d.ts

@@ -5,6 +5,8 @@
  * - log_decision
  * - get_decisions
  * - delete_decision
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const logDecision: Handler;

package/dist/handlers/decisions.js

@@ -5,53 +5,54 @@
  * - log_decision
  * - get_decisions
  * - delete_decision
+ *
+ * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
 import { validateRequired, validateUUID } from '../validators.js';
+import { getApiClient } from '../api-client.js';
 export const logDecision = async (args, ctx) => {
     const { project_id, title, description, rationale, alternatives_considered } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
     validateRequired(title, 'title');
     validateRequired(description, 'description');
-    const { supabase, session } = ctx;
-    const { error } = await supabase
-        .from('decisions')
-        .insert({
-        project_id,
+    const { session } = ctx;
+    const apiClient = getApiClient();
+    const response = await apiClient.logDecision(project_id, {
         title,
         description,
-        rationale: rationale || null,
-        alternatives_considered: alternatives_considered || null,
-        created_by: 'agent',
-        created_by_session_id: session.currentSessionId,
-    });
-    if (error)
-        throw new Error(`Failed to log decision: ${error.message}`);
-    return { result: { success: true, title } };
+        rationale,
+        alternatives_considered
+    }, session.currentSessionId || undefined);
+    if (!response.ok) {
+        throw new Error(`Failed to log decision: ${response.error}`);
+    }
+    return { result: { success: true, title, decision_id: response.data?.decision_id } };
 };
 export const getDecisions = async (args, ctx) => {
     const { project_id } = args;
     validateRequired(project_id, 'project_id');
     validateUUID(project_id, 'project_id');
-    const { data, error } = await ctx.supabase
-        .from('decisions')
-        .select('id, title, description, rationale, created_at')
-        .eq('project_id', project_id)
-        .order('created_at', { ascending: false });
-    if (error)
-        throw new Error(`Failed to fetch decisions: ${error.message}`);
-    return { result: { decisions: data || [] } };
+    const apiClient = getApiClient();
+    const response = await apiClient.getDecisions(project_id);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch decisions: ${response.error}`);
+    }
+    return {
+        result: {
+            decisions: response.data?.decisions || [],
+        },
+    };
 };
 export const deleteDecision = async (args, ctx) => {
     const { decision_id } = args;
     validateRequired(decision_id, 'decision_id');
     validateUUID(decision_id, 'decision_id');
-    const { error } = await ctx.supabase
-        .from('decisions')
-        .delete()
-        .eq('id', decision_id);
-    if (error)
-        throw new Error(`Failed to delete decision: ${error.message}`);
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteDecision(decision_id);
+    if (!response.ok) {
+        throw new Error(`Failed to delete decision: ${response.error}`);
+    }
     return { result: { success: true } };
 };
 /**