@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/sprints.js

@@ -14,36 +14,87 @@
  * - get_sprint_backlog
  * - get_sprint_velocity
  */
-import { validateRequired, validateUUID, validateEnum } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 const SPRINT_STATUSES = ['planning', 'active', 'in_review', 'retrospective', 'completed', 'cancelled'];
 const TASK_PHASES = ['pre', 'core', 'post'];
 const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'];
 const VERSION_BUMPS = ['patch', 'minor', 'major'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const createSprintSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    goal: { type: 'string' },
+    start_date: { type: 'string', required: true },
+    end_date: { type: 'string', required: true },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+};
+const updateSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    goal: { type: 'string' },
+    start_date: { type: 'string' },
+    end_date: { 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) },
+};
+const getSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    summary_only: { type: 'boolean', default: false },
+};
+const getSprintsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(SPRINT_STATUSES) },
+    limit: { type: 'number', default: 20 },
+    offset: { type: 'number', default: 0 },
+};
+const deleteSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const startSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const completeSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    retrospective_notes: { type: 'string' },
+    skip_retrospective: { type: 'boolean' },
+};
+const addTaskToSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    story_points: { type: 'number' },
+    phase: { type: 'string', validate: createEnumValidator(TASK_PHASES) },
+};
+const removeTaskFromSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getSprintBacklogSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    sprint_id: { type: 'string', validate: uuidValidator },
+};
+const getSprintVelocitySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 10 },
+};
 export const createSprint = async (args, ctx) => {
-    const { project_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
-    validateRequired(start_date, 'start_date');
-    validateRequired(end_date, 'end_date');
-    if (deploy_environment) {
-        validateEnum(deploy_environment, DEPLOY_ENVIRONMENTS, 'deploy_environment');
-    }
-    if (deploy_version_bump) {
-        validateEnum(deploy_version_bump, VERSION_BUMPS, 'deploy_version_bump');
-    }
+    const { project_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = parseArgs(args, createSprintSchema);
     // Validate date format and order
     const startDateObj = new Date(start_date);
     const endDateObj = new Date(end_date);
     if (isNaN(startDateObj.getTime())) {
-        throw new Error('Invalid start_date format. Use YYYY-MM-DD');
+        return { result: { error: 'Invalid start_date format. Use YYYY-MM-DD' }, isError: true };
     }
     if (isNaN(endDateObj.getTime())) {
-        throw new Error('Invalid end_date format. Use YYYY-MM-DD');
+        return { result: { error: 'Invalid end_date format. Use YYYY-MM-DD' }, isError: true };
     }
     if (endDateObj < startDateObj) {
-        throw new Error('end_date must be on or after start_date');
+        return { result: { error: 'end_date must be on or after start_date' }, isError: true };
     }
     const { session } = ctx;
     const apiClient = getApiClient();
@@ -62,7 +113,7 @@ export const createSprint = async (args, ctx) => {
         instance_id: session.instanceId
     });
     if (!response.ok) {
-        throw new Error(`Failed to create sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to create sprint' }, isError: true };
     }
     return {
         result: {
@@ -78,26 +129,18 @@ export const createSprint = async (args, ctx) => {
     };
 };
 export const updateSprint = async (args, ctx) => {
-    const { sprint_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    if (deploy_environment) {
-        validateEnum(deploy_environment, DEPLOY_ENVIRONMENTS, 'deploy_environment');
-    }
-    if (deploy_version_bump) {
-        validateEnum(deploy_version_bump, VERSION_BUMPS, 'deploy_version_bump');
-    }
+    const { sprint_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = parseArgs(args, updateSprintSchema);
     // Validate dates if provided
     if (start_date) {
         const startDateObj = new Date(start_date);
         if (isNaN(startDateObj.getTime())) {
-            throw new Error('Invalid start_date format. Use YYYY-MM-DD');
+            return { result: { error: 'Invalid start_date format. Use YYYY-MM-DD' }, isError: true };
         }
     }
     if (end_date) {
         const endDateObj = new Date(end_date);
         if (isNaN(endDateObj.getTime())) {
-            throw new Error('Invalid end_date format. Use YYYY-MM-DD');
+            return { result: { error: 'Invalid end_date format. Use YYYY-MM-DD' }, isError: true };
         }
     }
     const apiClient = getApiClient();
@@ -112,69 +155,56 @@ export const updateSprint = async (args, ctx) => {
         deploy_version_bump,
     });
     if (!response.ok) {
-        throw new Error(`Failed to update sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to update sprint' }, isError: true };
     }
     return { result: { success: true, sprint_id } };
 };
 export const getSprint = async (args, ctx) => {
-    const { sprint_id, summary_only = false } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id, summary_only } = parseArgs(args, getSprintSchema);
     const apiClient = getApiClient();
     // Response type varies based on summary_only
     const response = await apiClient.proxy('get_sprint', { sprint_id, summary_only });
     if (!response.ok) {
-        throw new Error(`Failed to get sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get sprint' }, isError: true };
     }
     return { result: response.data };
 };
 export const getSprints = async (args, ctx) => {
-    const { project_id, status, limit = 20, offset = 0 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (status) {
-        validateEnum(status, SPRINT_STATUSES, 'status');
-    }
+    const { project_id, status, limit, offset } = parseArgs(args, getSprintsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprints', {
         project_id,
         status,
-        limit: Math.min(limit, 100),
+        limit: Math.min(limit ?? 20, 100),
         offset,
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch sprints: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch sprints' }, isError: true };
     }
     return { result: response.data };
 };
 export const deleteSprint = async (args, ctx) => {
-    const { sprint_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id } = parseArgs(args, deleteSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('delete_sprint', {
         sprint_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to delete sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete sprint' }, isError: true };
     }
     return { result: { success: true, message: 'Sprint deleted. Tasks are preserved.' } };
 };
 export const startSprint = async (args, ctx) => {
-    const { sprint_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id } = parseArgs(args, startSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('start_sprint', { sprint_id });
     if (!response.ok) {
-        throw new Error(`Failed to start sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to start sprint' }, isError: true };
     }
     return { result: response.data };
 };
 export const completeSprint = async (args, ctx) => {
-    const { sprint_id, retrospective_notes, skip_retrospective } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id, retrospective_notes, skip_retrospective } = parseArgs(args, completeSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('complete_sprint', {
         sprint_id,
@@ -182,21 +212,14 @@ export const completeSprint = async (args, ctx) => {
         skip_retrospective,
     });
     if (!response.ok) {
-        throw new Error(`Failed to complete sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to complete sprint' }, isError: true };
     }
     return { result: response.data };
 };
 export const addTaskToSprint = async (args, ctx) => {
-    const { sprint_id, task_id, story_points, phase } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    if (phase) {
-        validateEnum(phase, TASK_PHASES, 'phase');
-    }
+    const { sprint_id, task_id, story_points, phase } = parseArgs(args, addTaskToSprintSchema);
     if (story_points !== undefined && (story_points < 0 || !Number.isInteger(story_points))) {
-        throw new Error('story_points must be a non-negative integer');
+        return { result: { error: 'story_points must be a non-negative integer' }, isError: true };
     }
     const apiClient = getApiClient();
     const response = await apiClient.proxy('add_task_to_sprint', {
@@ -206,54 +229,43 @@ export const addTaskToSprint = async (args, ctx) => {
         phase: phase || 'core',
     });
     if (!response.ok) {
-        throw new Error(`Failed to add task to sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add task to sprint' }, isError: true };
     }
     return { result: response.data };
 };
 export const removeTaskFromSprint = async (args, ctx) => {
-    const { sprint_id, task_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { sprint_id, task_id } = parseArgs(args, removeTaskFromSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_from_sprint', {
         sprint_id,
         task_id,
     });
     if (!response.ok) {
-        throw new Error(`Failed to remove task from sprint: ${response.error}`);
+        return { result: { error: response.error || 'Failed to remove task from sprint' }, isError: true };
     }
     return { result: response.data };
 };
 export const getSprintBacklog = async (args, ctx) => {
-    const { project_id, sprint_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (sprint_id) {
-        validateUUID(sprint_id, 'sprint_id');
-    }
+    const { project_id, sprint_id } = parseArgs(args, getSprintBacklogSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprint_backlog', {
         project_id,
         sprint_id,
     });
     if (!response.ok) {
-        throw new Error(`Failed to get sprint backlog: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get sprint backlog' }, isError: true };
     }
     return { result: response.data };
 };
 export const getSprintVelocity = async (args, ctx) => {
-    const { project_id, limit = 10 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, limit } = parseArgs(args, getSprintVelocitySchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprint_velocity', {
         project_id,
-        limit: Math.min(limit, 50),
+        limit: Math.min(limit ?? 10, 50),
     });
     if (!response.ok) {
-        throw new Error(`Failed to get sprint velocity: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get sprint velocity' }, isError: true };
     }
     return { result: response.data };
 };

package/dist/handlers/tasks.d.ts

@@ -42,6 +42,8 @@ export declare const batchUpdateTasks: Handler;
 export declare const batchCompleteTasks: Handler;
 export declare const addSubtask: Handler;
 export declare const getSubtasks: Handler;
+export declare const getStaleWorktrees: Handler;
+export declare const clearWorktreePath: Handler;
 /**
  * Task handlers registry
  */