@vibescope/mcp-server 0.1.0 → 0.2.1

package/dist/handlers/cost.js

@@ -9,20 +9,55 @@
  * - delete_cost_alert
  * - get_task_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 },
+};
+// 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 +69,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 +84,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 +106,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,12 +124,6 @@ export const updateCostAlert = async (args, ctx) => {
         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 apiClient = getApiClient();
     const response = await apiClient.updateCostAlert(alert_id, updates);
     if (!response.ok) {
@@ -117,14 +137,8 @@ export const updateCostAlert = async (args, ctx) => {
 /**
  * Delete a cost alert
  */
-export const deleteCostAlert = async (args, ctx) => {
-    const { alert_id } = args;
-    if (!alert_id) {
-        return {
-            result: { error: 'alert_id is required' },
-            isError: true,
-        };
-    }
+export const deleteCostAlert = async (args, _ctx) => {
+    const { alert_id } = parseArgs(args, deleteCostAlertSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteCostAlert(alert_id);
     if (!response.ok) {
@@ -138,14 +152,8 @@ export const deleteCostAlert = async (args, ctx) => {
 /**
  * Get task costs for a project
  */
-export const getTaskCosts = async (args, ctx) => {
-    const { project_id, limit = 20 } = args;
-    if (!project_id) {
-        return {
-            result: { error: 'project_id is required' },
-            isError: true,
-        };
-    }
+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) {

package/dist/handlers/decisions.js

@@ -8,33 +8,48 @@
  *
  * 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: { 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}`);
     }
@@ -44,10 +59,8 @@ 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) {

package/dist/handlers/deployment.js

@@ -13,21 +13,103 @@
  * - complete_deployment_requirement
  * - get_deployment_requirements
  */
-import { ValidationError, validateRequired, validateUUID, validateEnvironment, } from '../validators.js';
+import { ValidationError, parseArgs, uuidValidator, createEnumValidator, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const ENVIRONMENTS = ['development', 'staging', 'production'];
+const VERSION_BUMPS = ['patch', 'minor', 'major'];
+const REQUIREMENT_TYPES = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
+const REQUIREMENT_STAGES = ['preparation', 'deployment', 'verification'];
+const REQUIREMENT_STATUSES = ['pending', 'completed', 'converted_to_task', 'all'];
+const SCHEDULE_TYPES = ['once', 'daily', 'weekly', 'monthly'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const requestDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const claimDeploymentValidationSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const reportValidationSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    build_passed: { type: 'boolean', required: true },
+    tests_passed: { type: 'boolean' },
+    error_message: { type: 'string' },
+};
+const checkDeploymentStatusSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const startDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const completeDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    success: { type: 'boolean', required: true },
+    summary: { type: 'string' },
+};
+const cancelDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    reason: { type: 'string' },
+};
+const addDeploymentRequirementSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    type: { type: 'string', required: true, validate: createEnumValidator(REQUIREMENT_TYPES) },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    file_path: { type: 'string' },
+    stage: { type: 'string', default: 'preparation', validate: createEnumValidator(REQUIREMENT_STAGES) },
+    blocking: { type: 'boolean', default: false },
+    recurring: { type: 'boolean', default: false },
+};
+const completeDeploymentRequirementSchema = {
+    requirement_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getDeploymentRequirementsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', default: 'pending', validate: createEnumValidator(REQUIREMENT_STATUSES) },
+    stage: { type: 'string', validate: createEnumValidator([...REQUIREMENT_STAGES, 'all']) },
+};
+const scheduleDeploymentSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', default: 'production', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', default: 'patch', validate: createEnumValidator(VERSION_BUMPS) },
+    schedule_type: { type: 'string', default: 'once', validate: createEnumValidator(SCHEDULE_TYPES) },
+    scheduled_at: { type: 'string', required: true },
+    auto_trigger: { type: 'boolean', default: true },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const getScheduledDeploymentsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    include_disabled: { type: 'boolean', default: false },
+};
+const updateScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+    environment: { type: 'string', validate: createEnumValidator(ENVIRONMENTS) },
+    version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    schedule_type: { type: 'string', validate: createEnumValidator(SCHEDULE_TYPES) },
+    scheduled_at: { type: 'string' },
+    auto_trigger: { type: 'boolean' },
+    enabled: { type: 'boolean' },
+    notes: { type: 'string' },
+    git_ref: { type: 'string' },
+};
+const deleteScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const triggerScheduledDeploymentSchema = {
+    schedule_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const checkDueDeploymentsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const requestDeployment = async (args, ctx) => {
-    const { project_id, environment = 'production', version_bump = 'patch', notes, git_ref } = args;
+    const { project_id, environment, version_bump, notes, git_ref } = parseArgs(args, requestDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateEnvironment(environment);
-    if (version_bump && !['patch', 'minor', 'major'].includes(version_bump)) {
-        throw new ValidationError('Invalid version_bump value', {
-            field: 'version_bump',
-            validValues: ['patch', 'minor', 'major'],
-            hint: 'Must be one of: patch, minor, major',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.requestDeployment(project_id, {
         environment,
@@ -41,10 +123,8 @@ export const requestDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const claimDeploymentValidation = async (args, ctx) => {
-    const { project_id } = args;
+    const { project_id } = parseArgs(args, claimDeploymentValidationSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
     const apiClient = getApiClient();
     const response = await apiClient.claimDeploymentValidation(project_id, session.currentSessionId || undefined);
     if (!response.ok) {
@@ -53,16 +133,8 @@ export const claimDeploymentValidation = async (args, ctx) => {
     return { result: response.data };
 };
 export const reportValidation = async (args, ctx) => {
-    const { project_id, build_passed, tests_passed, error_message } = args;
+    const { project_id, build_passed, tests_passed, error_message } = parseArgs(args, reportValidationSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (build_passed === undefined) {
-        throw new ValidationError('build_passed is required', {
-            field: 'build_passed',
-            hint: 'Set to true if the build succeeded, false otherwise',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.reportValidation(project_id, {
         build_passed,
@@ -75,9 +147,7 @@ export const reportValidation = async (args, ctx) => {
     return { result: response.data };
 };
 export const checkDeploymentStatus = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, checkDeploymentStatusSchema);
     const apiClient = getApiClient();
     const response = await apiClient.checkDeploymentStatus(project_id);
     if (!response.ok) {
@@ -86,10 +156,8 @@ export const checkDeploymentStatus = async (args, ctx) => {
     return { result: response.data };
 };
 export const startDeployment = async (args, ctx) => {
-    const { project_id } = args;
+    const { project_id } = parseArgs(args, startDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
     const apiClient = getApiClient();
     const response = await apiClient.startDeployment(project_id, session.currentSessionId || undefined);
     if (!response.ok) {
@@ -98,16 +166,8 @@ export const startDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const completeDeployment = async (args, ctx) => {
-    const { project_id, success, summary } = args;
+    const { project_id, success, summary } = parseArgs(args, completeDeploymentSchema);
     const { session } = ctx;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (success === undefined) {
-        throw new ValidationError('success is required', {
-            field: 'success',
-            hint: 'Set to true if deployment succeeded, false otherwise',
-        });
-    }
     const apiClient = getApiClient();
     const response = await apiClient.completeDeployment(project_id, {
         success,
@@ -119,9 +179,7 @@ export const completeDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const cancelDeployment = async (args, ctx) => {
-    const { project_id, reason } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, reason } = parseArgs(args, cancelDeploymentSchema);
     const apiClient = getApiClient();
     const response = await apiClient.cancelDeployment(project_id, reason);
     if (!response.ok) {
@@ -130,19 +188,7 @@ export const cancelDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const addDeploymentRequirement = async (args, ctx) => {
-    const { project_id, type, title, description, file_path, stage = 'preparation', blocking = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(type, 'type');
-    validateRequired(title, 'title');
-    const validTypes = ['migration', 'env_var', 'config', 'manual', 'breaking_change', 'agent_task'];
-    if (!validTypes.includes(type)) {
-        throw new ValidationError(`type must be one of: ${validTypes.join(', ')}`);
-    }
-    const validStages = ['preparation', 'deployment', 'verification'];
-    if (!validStages.includes(stage)) {
-        throw new ValidationError(`stage must be one of: ${validStages.join(', ')}`);
-    }
+    const { project_id, type, title, description, file_path, stage, blocking, recurring } = parseArgs(args, addDeploymentRequirementSchema);
     const apiClient = getApiClient();
     const response = await apiClient.addDeploymentRequirement(project_id, {
         type: type,
@@ -150,7 +196,8 @@ export const addDeploymentRequirement = async (args, ctx) => {
         description,
         file_path,
         stage: stage,
-        blocking
+        blocking,
+        recurring
     });
     if (!response.ok) {
         throw new Error(response.error || 'Failed to add deployment requirement');
@@ -158,9 +205,7 @@ export const addDeploymentRequirement = async (args, ctx) => {
     return { result: response.data };
 };
 export const completeDeploymentRequirement = async (args, ctx) => {
-    const { requirement_id } = args;
-    validateRequired(requirement_id, 'requirement_id');
-    validateUUID(requirement_id, 'requirement_id');
+    const { requirement_id } = parseArgs(args, completeDeploymentRequirementSchema);
     const apiClient = getApiClient();
     const response = await apiClient.completeDeploymentRequirement(requirement_id);
     if (!response.ok) {
@@ -169,9 +214,7 @@ export const completeDeploymentRequirement = async (args, ctx) => {
     return { result: response.data };
 };
 export const getDeploymentRequirements = async (args, ctx) => {
-    const { project_id, status = 'pending', stage } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, status, stage } = parseArgs(args, getDeploymentRequirementsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getDeploymentRequirements(project_id, {
         status: status,
@@ -186,23 +229,7 @@ export const getDeploymentRequirements = async (args, ctx) => {
 // Scheduled Deployments
 // ============================================================================
 export const scheduleDeployment = async (args, ctx) => {
-    const { project_id, environment = 'production', version_bump = 'patch', schedule_type = 'once', scheduled_at, auto_trigger = true, notes, git_ref, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(scheduled_at, 'scheduled_at');
-    validateEnvironment(environment);
-    if (!['patch', 'minor', 'major'].includes(version_bump)) {
-        throw new ValidationError('Invalid version_bump value', {
-            field: 'version_bump',
-            validValues: ['patch', 'minor', 'major'],
-        });
-    }
-    if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-        throw new ValidationError('Invalid schedule_type value', {
-            field: 'schedule_type',
-            validValues: ['once', 'daily', 'weekly', 'monthly'],
-        });
-    }
+    const { project_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, notes, git_ref, } = parseArgs(args, scheduleDeploymentSchema);
     // Parse and validate scheduled_at
     const scheduledDate = new Date(scheduled_at);
     if (isNaN(scheduledDate.getTime())) {
@@ -232,9 +259,7 @@ export const scheduleDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const getScheduledDeployments = async (args, ctx) => {
-    const { project_id, include_disabled = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, include_disabled } = parseArgs(args, getScheduledDeploymentsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getScheduledDeployments(project_id, include_disabled);
     if (!response.ok) {
@@ -243,26 +268,14 @@ export const getScheduledDeployments = async (args, ctx) => {
     return { result: response.data };
 };
 export const updateScheduledDeployment = async (args, ctx) => {
-    const { schedule_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, enabled, notes, git_ref, } = args;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
+    const { schedule_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, enabled, notes, git_ref, } = parseArgs(args, updateScheduledDeploymentSchema);
     const updates = {};
-    if (environment !== undefined) {
-        validateEnvironment(environment);
+    if (environment !== undefined)
         updates.environment = environment;
-    }
-    if (version_bump !== undefined) {
-        if (!['patch', 'minor', 'major'].includes(version_bump)) {
-            throw new ValidationError('Invalid version_bump value');
-        }
+    if (version_bump !== undefined)
         updates.version_bump = version_bump;
-    }
-    if (schedule_type !== undefined) {
-        if (!['once', 'daily', 'weekly', 'monthly'].includes(schedule_type)) {
-            throw new ValidationError('Invalid schedule_type value');
-        }
+    if (schedule_type !== undefined)
         updates.schedule_type = schedule_type;
-    }
     if (scheduled_at !== undefined) {
         const scheduledDate = new Date(scheduled_at);
         if (isNaN(scheduledDate.getTime())) {
@@ -289,9 +302,7 @@ export const updateScheduledDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const deleteScheduledDeployment = async (args, ctx) => {
-    const { schedule_id } = args;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
+    const { schedule_id } = parseArgs(args, deleteScheduledDeploymentSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteScheduledDeployment(schedule_id);
     if (!response.ok) {
@@ -300,10 +311,8 @@ export const deleteScheduledDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const triggerScheduledDeployment = async (args, ctx) => {
-    const { schedule_id } = args;
+    const { schedule_id } = parseArgs(args, triggerScheduledDeploymentSchema);
     const { session } = ctx;
-    validateRequired(schedule_id, 'schedule_id');
-    validateUUID(schedule_id, 'schedule_id');
     const apiClient = getApiClient();
     const response = await apiClient.triggerScheduledDeployment(schedule_id, session.currentSessionId || undefined);
     if (!response.ok) {
@@ -312,9 +321,7 @@ export const triggerScheduledDeployment = async (args, ctx) => {
     return { result: response.data };
 };
 export const checkDueDeployments = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, checkDueDeploymentsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.checkDueDeployments(project_id);
     if (!response.ok) {

package/dist/handlers/discovery.d.ts

@@ -4,6 +4,9 @@
  * Handles tool discovery and documentation:
  * - discover_tools
  * - get_tool_info
+ *
+ * Note: Tool documentation is lazy-loaded from tool-docs.ts to save tokens.
+ * This saves ~8,000 tokens per schema load.
  */
 import type { Handler, HandlerRegistry } from './types.js';
 export declare const discoverTools: Handler;