@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/cost.js

@@ -8,21 +8,66 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_PERIODS = ['daily', 'weekly', 'monthly'];
+const VALID_ALERT_TYPES = ['warning', 'critical'];
+// Argument schemas for type-safe parsing
+const getCostSummarySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    period: { type: 'string', default: 'daily', validate: createEnumValidator(VALID_PERIODS) },
+    limit: { type: 'number', default: 30 },
+};
+const getCostAlertsSchema = {
+    project_id: { type: 'string', validate: uuidValidator },
+};
+const addCostAlertSchema = {
+    project_id: { type: 'string', validate: uuidValidator },
+    threshold_amount: { type: 'number', required: true },
+    threshold_period: { type: 'string', required: true, validate: createEnumValidator(VALID_PERIODS) },
+    alert_type: { type: 'string', default: 'warning', validate: createEnumValidator(VALID_ALERT_TYPES) },
+};
+const updateCostAlertSchema = {
+    alert_id: { type: 'string', required: true, validate: uuidValidator },
+    threshold_amount: { type: 'number' },
+    threshold_period: { type: 'string', validate: createEnumValidator(VALID_PERIODS) },
+    alert_type: { type: 'string', validate: createEnumValidator(VALID_ALERT_TYPES) },
+    enabled: { type: 'boolean' },
+};
+const deleteCostAlertSchema = {
+    alert_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getTaskCostsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 20 },
+};
+const getBodyOfWorkCostsSchema = {
+    body_of_work_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+};
+const getSprintCostsSchema = {
+    sprint_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+};
+// Custom validator for positive numbers
+function validatePositiveNumber(value, fieldName) {
+    if (value !== undefined && value <= 0) {
+        throw new ValidationError(`${fieldName} must be a positive number`, { field: fieldName });
+    }
+}
 /**
  * Get cost summary for a project (daily, weekly, or monthly)
  */
-export const getCostSummary = async (args, ctx) => {
-    const { project_id, period = 'daily', limit = 30 } = args;
-    if (!project_id) {
-        return {
-            result: { error: 'project_id is required' },
-            isError: true,
-        };
-    }
+export const getCostSummary = async (args, _ctx) => {
+    const { project_id, period, limit } = parseArgs(args, getCostSummarySchema);
     const apiClient = getApiClient();
-    const response = await apiClient.getCostSummary(project_id, { period, limit });
+    const response = await apiClient.getCostSummary(project_id, {
+        period: period,
+        limit
+    });
     if (!response.ok) {
         return {
             result: { error: response.error || 'Failed to get cost summary' },
@@ -34,8 +79,8 @@ export const getCostSummary = async (args, ctx) => {
 /**
  * Get cost alerts for the current user
  */
-export const getCostAlerts = async (args, ctx) => {
-    const { project_id } = args;
+export const getCostAlerts = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, getCostAlertsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getCostAlerts();
     if (!response.ok) {
@@ -49,26 +94,16 @@ export const getCostAlerts = async (args, ctx) => {
 /**
  * Add a cost alert
  */
-export const addCostAlert = async (args, ctx) => {
-    const { project_id, threshold_amount, threshold_period, alert_type = 'warning', } = args;
-    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,
-        };
-    }
+export const addCostAlert = async (args, _ctx) => {
+    const { project_id, threshold_amount, threshold_period, alert_type } = parseArgs(args, addCostAlertSchema);
+    // Additional validation for positive amount
+    validatePositiveNumber(threshold_amount, 'threshold_amount');
     const apiClient = getApiClient();
     const response = await apiClient.addCostAlert({
         project_id,
-        threshold_amount,
-        threshold_period,
-        alert_type
+        threshold_amount: threshold_amount,
+        threshold_period: threshold_period,
+        alert_type: alert_type
     });
     if (!response.ok) {
         return {
@@ -81,11 +116,12 @@ export const addCostAlert = async (args, ctx) => {
 /**
  * Update a cost alert
  */
-export const updateCostAlert = async (args, ctx) => {
-    const { alert_id, threshold_amount, threshold_period, alert_type, enabled, } = args;
-    if (!alert_id) {
+export const updateCostAlert = async (args, _ctx) => {
+    const { alert_id, threshold_amount, threshold_period, alert_type, enabled } = parseArgs(args, updateCostAlertSchema);
+    // Check that at least one update is provided
+    if (threshold_amount === undefined && threshold_period === undefined && alert_type === undefined && enabled === undefined) {
         return {
-            result: { error: 'alert_id is required' },
+            result: { error: 'No updates provided' },
             isError: true,
         };
     }
@@ -98,59 +134,83 @@ export const updateCostAlert = async (args, ctx) => {
         updates.alert_type = alert_type;
     if (enabled !== undefined)
         updates.enabled = enabled;
-    if (Object.keys(updates).length === 0) {
+    const apiClient = getApiClient();
+    const response = await apiClient.updateCostAlert(alert_id, updates);
+    if (!response.ok) {
         return {
-            result: { error: 'No updates provided' },
+            result: { error: response.error || 'Failed to update cost alert' },
             isError: true,
         };
     }
+    return { result: response.data };
+};
+/**
+ * Delete a cost alert
+ */
+export const deleteCostAlert = async (args, _ctx) => {
+    const { alert_id } = parseArgs(args, deleteCostAlertSchema);
     const apiClient = getApiClient();
-    const response = await apiClient.updateCostAlert(alert_id, updates);
+    const response = await apiClient.deleteCostAlert(alert_id);
     if (!response.ok) {
         return {
-            result: { error: response.error || 'Failed to update cost alert' },
+            result: { error: response.error || 'Failed to delete cost alert' },
             isError: true,
         };
     }
     return { result: response.data };
 };
 /**
- * Delete a cost alert
+ * Get task costs for a project
+ */
+export const getTaskCosts = async (args, _ctx) => {
+    const { project_id, limit } = parseArgs(args, getTaskCostsSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getTaskCosts(project_id, limit);
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to get task costs' },
+            isError: true,
+        };
+    }
+    return { result: response.data };
+};
+/**
+ * Get body of work costs with phase breakdown
  */
-export const deleteCostAlert = async (args, ctx) => {
-    const { alert_id } = args;
-    if (!alert_id) {
+export const getBodyOfWorkCosts = async (args, _ctx) => {
+    const { body_of_work_id, project_id } = parseArgs(args, getBodyOfWorkCostsSchema);
+    if (!body_of_work_id && !project_id) {
         return {
-            result: { error: 'alert_id is required' },
+            result: { error: 'Either body_of_work_id or project_id is required' },
             isError: true,
         };
     }
     const apiClient = getApiClient();
-    const response = await apiClient.deleteCostAlert(alert_id);
+    const response = await apiClient.getBodyOfWorkCosts({ body_of_work_id, project_id });
     if (!response.ok) {
         return {
-            result: { error: response.error || 'Failed to delete cost alert' },
+            result: { error: response.error || 'Failed to get body of work costs' },
             isError: true,
         };
     }
     return { result: response.data };
 };
 /**
- * Get task costs for a project
+ * Get sprint costs with velocity metrics
  */
-export const getTaskCosts = async (args, ctx) => {
-    const { project_id, limit = 20 } = args;
-    if (!project_id) {
+export const getSprintCosts = async (args, _ctx) => {
+    const { sprint_id, project_id } = parseArgs(args, getSprintCostsSchema);
+    if (!sprint_id && !project_id) {
         return {
-            result: { error: 'project_id is required' },
+            result: { error: 'Either sprint_id or project_id is required' },
             isError: true,
         };
     }
     const apiClient = getApiClient();
-    const response = await apiClient.getTaskCosts(project_id, limit);
+    const response = await apiClient.getSprintCosts({ sprint_id, project_id });
     if (!response.ok) {
         return {
-            result: { error: response.error || 'Failed to get task costs' },
+            result: { error: response.error || 'Failed to get sprint costs' },
             isError: true,
         };
     }
@@ -166,4 +226,6 @@ export const costHandlers = {
     update_cost_alert: updateCostAlert,
     delete_cost_alert: deleteCostAlert,
     get_task_costs: getTaskCosts,
+    get_body_of_work_costs: getBodyOfWorkCosts,
+    get_sprint_costs: getSprintCosts,
 };

package/dist/handlers/decisions.js

@@ -8,35 +8,50 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Argument schemas for type-safe parsing
+const logDecisionSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string', required: true },
+    rationale: { type: 'string' },
+    alternatives_considered: { type: 'array' },
+};
+const getDecisionsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteDecisionSchema = {
+    decision_id: { type: 'string', required: true, validate: uuidValidator },
+};
 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 { project_id, title, description, rationale, alternatives_considered } = parseArgs(args, logDecisionSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.logDecision(project_id, {
         title,
         description,
         rationale,
-        alternatives_considered
+        alternatives_considered: alternatives_considered
     }, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to log decision: ${response.error}`);
+        return { result: { error: response.error || 'Failed to log decision' }, isError: true };
     }
     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');
+export const getDecisions = 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}`);
+        return { result: { error: response.error || 'Failed to fetch decisions' }, isError: true };
     }
     return {
         result: {
@@ -44,14 +59,12 @@ export const getDecisions = async (args, ctx) => {
         },
     };
 };
-export const deleteDecision = async (args, ctx) => {
-    const { decision_id } = args;
-    validateRequired(decision_id, 'decision_id');
-    validateUUID(decision_id, 'decision_id');
+export const deleteDecision = async (args, _ctx) => {
+    const { decision_id } = parseArgs(args, deleteDecisionSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteDecision(decision_id);
     if (!response.ok) {
-        throw new Error(`Failed to delete decision: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete decision' }, isError: true };
     }
     return { result: { success: true } };
 };