@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/bodies-of-work.js

@@ -17,13 +17,78 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const BODY_OF_WORK_STATUSES = ['draft', 'active', 'completed', 'cancelled'];
+const TASK_PHASES = ['pre', 'core', 'post'];
+const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'];
+const VERSION_BUMPS = ['patch', 'minor', 'major'];
+const DEPLOY_TRIGGERS = ['all_completed', 'all_completed_validated'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const createBodyOfWorkSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    deploy_trigger: { type: 'string', validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+const updateBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    deploy_trigger: { type: 'string', validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+const getBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    summary_only: { type: 'boolean', default: false },
+};
+const getBodiesOfWorkSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(BODY_OF_WORK_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskToBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    phase: { type: 'string', validate: createEnumValidator(TASK_PHASES) },
+    order_index: { type: 'number' },
+};
+const removeTaskFromBodyOfWorkSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const activateBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskDependencySchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    depends_on_task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const removeTaskDependencySchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    depends_on_task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getTaskDependenciesSchema = {
+    body_of_work_id: { type: 'string', validate: uuidValidator },
+    task_id: { type: 'string', validate: uuidValidator },
+};
+const getNextBodyOfWorkTaskSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const createBodyOfWork = async (args, ctx) => {
-    const { project_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
+    const { project_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = parseArgs(args, createBodyOfWorkSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.proxy('create_body_of_work', {
@@ -40,7 +105,7 @@ export const createBodyOfWork = async (args, ctx) => {
         instance_id: session.instanceId
     });
     if (!response.ok) {
-        throw new Error(`Failed to create body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to create body of work' }, isError: true };
     }
     return {
         result: {
@@ -53,9 +118,7 @@ export const createBodyOfWork = async (args, ctx) => {
     };
 };
 export const updateBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = parseArgs(args, updateBodyOfWorkSchema);
     // Check if any updates provided
     if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
         deploy_environment === undefined && deploy_version_bump === undefined && deploy_trigger === undefined) {
@@ -72,58 +135,48 @@ export const updateBodyOfWork = async (args, ctx) => {
         deploy_trigger
     });
     if (!response.ok) {
-        throw new Error(`Failed to update body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to update body of work' }, isError: true };
     }
     return { result: { success: true, body_of_work_id } };
 };
 export const getBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, summary_only = false } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id, summary_only } = parseArgs(args, getBodyOfWorkSchema);
     const apiClient = getApiClient();
     // Response type varies based on summary_only
     const response = await apiClient.proxy('get_body_of_work', { body_of_work_id, summary_only });
     if (!response.ok) {
-        throw new Error(`Failed to get body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get body of work' }, isError: true };
     }
     return { result: response.data };
 };
 export const getBodiesOfWork = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, status, limit, offset, search_query } = parseArgs(args, getBodiesOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_bodies_of_work', {
         project_id,
         status,
-        limit: Math.min(limit, 100),
+        limit: Math.min(limit ?? 50, 100),
         offset,
         search_query
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch bodies of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch bodies of work' }, isError: true };
     }
     return { result: response.data };
 };
 export const deleteBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, deleteBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('delete_body_of_work', {
         body_of_work_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to delete body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete body of work' }, isError: true };
     }
     return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
 };
 export const addTaskToBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, task_id, phase, order_index } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { body_of_work_id, task_id, phase, order_index } = parseArgs(args, addTaskToBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('add_task_to_body_of_work', {
         body_of_work_id,
@@ -132,42 +185,32 @@ export const addTaskToBodyOfWork = async (args, ctx) => {
         order_index
     });
     if (!response.ok) {
-        throw new Error(`Failed to add task to body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add task to body of work' }, isError: true };
     }
     return { result: response.data };
 };
 export const removeTaskFromBodyOfWork = async (args, ctx) => {
-    const { task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { task_id } = parseArgs(args, removeTaskFromBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_from_body_of_work', { task_id });
     if (!response.ok) {
-        throw new Error(`Failed to remove task from body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to remove task from body of work' }, isError: true };
     }
     return { result: response.data };
 };
 export const activateBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, activateBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('activate_body_of_work', { body_of_work_id });
     if (!response.ok) {
-        throw new Error(`Failed to activate body of work: ${response.error}`);
+        return { result: { error: response.error || 'Failed to activate body of work' }, isError: true };
     }
     return { result: response.data };
 };
 export const addTaskDependency = async (args, ctx) => {
-    const { body_of_work_id, task_id, depends_on_task_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(depends_on_task_id, 'depends_on_task_id');
-    validateUUID(depends_on_task_id, 'depends_on_task_id');
+    const { body_of_work_id, task_id, depends_on_task_id } = parseArgs(args, addTaskDependencySchema);
     if (task_id === depends_on_task_id) {
-        throw new Error('A task cannot depend on itself');
+        return { result: { error: 'A task cannot depend on itself' }, isError: true };
     }
     const apiClient = getApiClient();
     const response = await apiClient.proxy('add_task_dependency', {
@@ -176,53 +219,43 @@ export const addTaskDependency = async (args, ctx) => {
         depends_on_task_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to add task dependency: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add task dependency' }, isError: true };
     }
     return { result: response.data };
 };
 export const removeTaskDependency = async (args, ctx) => {
-    const { task_id, depends_on_task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(depends_on_task_id, 'depends_on_task_id');
-    validateUUID(depends_on_task_id, 'depends_on_task_id');
+    const { task_id, depends_on_task_id } = parseArgs(args, removeTaskDependencySchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_dependency', {
         task_id,
         depends_on_task_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to remove task dependency: ${response.error}`);
+        return { result: { error: response.error || 'Failed to remove task dependency' }, isError: true };
     }
     return { result: response.data };
 };
 export const getTaskDependencies = async (args, ctx) => {
-    const { body_of_work_id, task_id } = args;
+    const { body_of_work_id, task_id } = parseArgs(args, getTaskDependenciesSchema);
     if (!body_of_work_id && !task_id) {
-        throw new Error('Either body_of_work_id or task_id is required');
+        return { result: { error: 'Either body_of_work_id or task_id is required' }, isError: true };
     }
-    if (body_of_work_id)
-        validateUUID(body_of_work_id, 'body_of_work_id');
-    if (task_id)
-        validateUUID(task_id, 'task_id');
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_task_dependencies', {
         body_of_work_id,
         task_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch task dependencies: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch task dependencies' }, isError: true };
     }
     return { result: response.data };
 };
 export const getNextBodyOfWorkTask = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, getNextBodyOfWorkTaskSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_next_body_of_work_task', { body_of_work_id });
     if (!response.ok) {
-        throw new Error(`Failed to get next body of work task: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get next body of work task' }, isError: true };
     }
     return { result: response.data };
 };

package/dist/handlers/connectors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Connectors Handlers
+ *
+ * Handles external integration management:
+ * - get_connectors
+ * - get_connector
+ * - add_connector
+ * - update_connector
+ * - delete_connector
+ * - test_connector
+ * - get_connector_events
+ */
+import type { Handler, HandlerRegistry } from './types.js';
+/**
+ * Get all connectors for a project
+ */
+export declare const getConnectors: Handler;
+/**
+ * Get a single connector with full details
+ */
+export declare const getConnector: Handler;
+/**
+ * Add a new connector
+ */
+export declare const addConnector: Handler;
+/**
+ * Update a connector
+ */
+export declare const updateConnector: Handler;
+/**
+ * Delete a connector
+ */
+export declare const deleteConnector: Handler;
+/**
+ * Test a connector by sending a test event
+ */
+export declare const testConnector: Handler;
+/**
+ * Get connector event history
+ */
+export declare const getConnectorEvents: Handler;
+/**
+ * Connectors handlers registry
+ */
+export declare const connectorHandlers: HandlerRegistry;

package/dist/handlers/connectors.js

@@ -0,0 +1,183 @@
+/**
+ * Connectors Handlers
+ *
+ * Handles external integration management:
+ * - get_connectors
+ * - get_connector
+ * - add_connector
+ * - update_connector
+ * - delete_connector
+ * - test_connector
+ * - get_connector_events
+ */
+import { success, error } from './types.js';
+import { parseArgs, uuidValidator, createEnumValidator, } from '../validators.js';
+import { getApiClient } from '../api-client.js';
+// Valid connector types
+const VALID_CONNECTOR_TYPES = ['webhook', 'slack', 'discord', 'github', 'custom'];
+// Valid connector statuses
+const VALID_CONNECTOR_STATUSES = ['active', 'disabled'];
+// Valid event statuses
+const VALID_EVENT_STATUSES = ['pending', 'sent', 'failed', 'retrying'];
+// Argument schemas for type-safe parsing
+const getConnectorsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    type: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+    status: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+};
+const getConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addConnectorSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string', required: true },
+    type: { type: 'string', required: true, validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+    description: { type: 'string' },
+    config: { type: 'object' },
+    events: { type: 'object' },
+};
+const updateConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string' },
+    description: { type: 'string' },
+    config: { type: 'object' },
+    events: { type: 'object' },
+    status: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+};
+const deleteConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const testConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getConnectorEventsSchema = {
+    connector_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(VALID_EVENT_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+};
+/**
+ * Get all connectors for a project
+ */
+export const getConnectors = async (args, _ctx) => {
+    const { project_id, type, status, limit, offset } = parseArgs(args, getConnectorsSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnectors(project_id, {
+        type,
+        status,
+        limit,
+        offset
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connectors');
+    }
+    return success(response.data);
+};
+/**
+ * Get a single connector with full details
+ */
+export const getConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, getConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connector');
+    }
+    return success(response.data);
+};
+/**
+ * Add a new connector
+ */
+export const addConnector = async (args, _ctx) => {
+    const { project_id, name, type, description, config, events } = parseArgs(args, addConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.addConnector(project_id, {
+        name,
+        type,
+        description,
+        config: config,
+        events: events
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to create connector');
+    }
+    return success(response.data);
+};
+/**
+ * Update a connector
+ */
+export const updateConnector = async (args, _ctx) => {
+    const { connector_id, name, description, config, events, status } = parseArgs(args, updateConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.updateConnector(connector_id, {
+        name,
+        description,
+        config: config,
+        events: events,
+        status
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to update connector');
+    }
+    return success(response.data);
+};
+/**
+ * Delete a connector
+ */
+export const deleteConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, deleteConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to delete connector');
+    }
+    return success(response.data);
+};
+/**
+ * Test a connector by sending a test event
+ */
+export const testConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, testConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.testConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to test connector');
+    }
+    return success(response.data);
+};
+/**
+ * Get connector event history
+ */
+export const getConnectorEvents = async (args, _ctx) => {
+    const { connector_id, project_id, status, limit, offset } = parseArgs(args, getConnectorEventsSchema);
+    if (!connector_id && !project_id) {
+        return error('Either connector_id or project_id is required');
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnectorEvents({
+        connector_id,
+        project_id,
+        status,
+        limit,
+        offset
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connector events');
+    }
+    return success(response.data);
+};
+/**
+ * Connectors handlers registry
+ */
+export const connectorHandlers = {
+    get_connectors: getConnectors,
+    get_connector: getConnector,
+    add_connector: addConnector,
+    update_connector: updateConnector,
+    delete_connector: deleteConnector,
+    test_connector: testConnector,
+    get_connector_events: getConnectorEvents,
+};

package/dist/handlers/cost.d.ts

@@ -8,6 +8,8 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
 import type { Handler, HandlerRegistry } from './types.js';
 /**
@@ -34,6 +36,14 @@ export declare const deleteCostAlert: Handler;
  * Get task costs for a project
  */
 export declare const getTaskCosts: Handler;
+/**
+ * Get body of work costs with phase breakdown
+ */
+export declare const getBodyOfWorkCosts: Handler;
+/**
+ * Get sprint costs with velocity metrics
+ */
+export declare const getSprintCosts: Handler;
 /**
  * Cost handlers registry
  */