@vibescope/mcp-server 0.4.4 → 0.4.6

package/dist/api-client/bodies-of-work.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Bodies of Work API Methods
+ *
+ * Methods for body-of-work management:
+ * - createBodyOfWork: Create a new body of work
+ * - getBodyOfWork: Get a single body of work with tasks
+ * - getBodiesOfWork: List bodies of work for a project
+ * - updateBodyOfWork: Update body of work settings
+ * - deleteBodyOfWork: Delete a body of work
+ * - addTaskToBodyOfWork: Add a task to a body of work
+ * - removeTaskFromBodyOfWork: Remove a task from its body of work
+ * - activateBodyOfWork: Activate a draft body of work
+ * - addTaskDependency: Add a dependency between tasks
+ * - removeTaskDependency: Remove a task dependency
+ * - getTaskDependencies: Get dependencies for a body of work or task
+ * - getNextBodyOfWorkTask: Get next available task from a body of work
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface BodiesOfWorkMethods {
+    createBodyOfWork(projectId: string, params: {
+        title: string;
+        description?: string;
+        auto_deploy_on_completion?: boolean;
+        deploy_environment?: string;
+        deploy_version_bump?: string;
+        deploy_trigger?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        body_of_work_id: string;
+    }>>;
+    getBodyOfWork(bodyOfWorkId: string): Promise<ApiResponse<{
+        body_of_work: {
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            auto_deploy_on_completion: boolean;
+        };
+        tasks: {
+            pre: Array<{
+                id: string;
+                title: string;
+                status: string;
+            }>;
+            core: Array<{
+                id: string;
+                title: string;
+                status: string;
+            }>;
+            post: Array<{
+                id: string;
+                title: string;
+                status: string;
+            }>;
+        };
+    }>>;
+    getBodiesOfWork(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        bodies_of_work: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            task_counts: {
+                pre: number;
+                core: number;
+                post: number;
+            };
+        }>;
+    }>>;
+    updateBodyOfWork(bodyOfWorkId: string, updates: {
+        title?: string;
+        description?: string;
+        auto_deploy_on_completion?: boolean;
+        deploy_environment?: string;
+        deploy_version_bump?: string;
+        deploy_trigger?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    deleteBodyOfWork(bodyOfWorkId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    addTaskToBodyOfWork(bodyOfWorkId: string, taskId: string, phase?: string, orderIndex?: number): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    removeTaskFromBodyOfWork(taskId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    activateBodyOfWork(bodyOfWorkId: string): Promise<ApiResponse<{
+        success: boolean;
+        status: string;
+    }>>;
+    addTaskDependency(bodyOfWorkId: string, taskId: string, dependsOnTaskId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    removeTaskDependency(taskId: string, dependsOnTaskId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getTaskDependencies(params: {
+        body_of_work_id?: string;
+        task_id?: string;
+    }): Promise<ApiResponse<{
+        dependencies: Array<{
+            id: string;
+            task_id: string;
+            depends_on_task_id: string;
+            created_at: string;
+        }>;
+    }>>;
+    getNextBodyOfWorkTask(bodyOfWorkId: string): Promise<ApiResponse<{
+        task?: {
+            id: string;
+            title: string;
+            priority: number;
+            phase: string;
+        } | null;
+        message?: string;
+    }>>;
+}
+export declare function createBodiesOfWorkMethods(proxy: ProxyFn): BodiesOfWorkMethods;

package/dist/api-client/bodies-of-work.js

@@ -0,0 +1,78 @@
+/**
+ * Bodies of Work API Methods
+ *
+ * Methods for body-of-work management:
+ * - createBodyOfWork: Create a new body of work
+ * - getBodyOfWork: Get a single body of work with tasks
+ * - getBodiesOfWork: List bodies of work for a project
+ * - updateBodyOfWork: Update body of work settings
+ * - deleteBodyOfWork: Delete a body of work
+ * - addTaskToBodyOfWork: Add a task to a body of work
+ * - removeTaskFromBodyOfWork: Remove a task from its body of work
+ * - activateBodyOfWork: Activate a draft body of work
+ * - addTaskDependency: Add a dependency between tasks
+ * - removeTaskDependency: Remove a task dependency
+ * - getTaskDependencies: Get dependencies for a body of work or task
+ * - getNextBodyOfWorkTask: Get next available task from a body of work
+ */
+export function createBodiesOfWorkMethods(proxy) {
+    return {
+        async createBodyOfWork(projectId, params) {
+            return proxy('create_body_of_work', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getBodyOfWork(bodyOfWorkId) {
+            return proxy('get_body_of_work', { body_of_work_id: bodyOfWorkId });
+        },
+        async getBodiesOfWork(projectId, params) {
+            return proxy('get_bodies_of_work', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async updateBodyOfWork(bodyOfWorkId, updates) {
+            return proxy('update_body_of_work', {
+                body_of_work_id: bodyOfWorkId,
+                ...updates
+            });
+        },
+        async deleteBodyOfWork(bodyOfWorkId) {
+            return proxy('delete_body_of_work', { body_of_work_id: bodyOfWorkId });
+        },
+        async addTaskToBodyOfWork(bodyOfWorkId, taskId, phase, orderIndex) {
+            return proxy('add_task_to_body_of_work', {
+                body_of_work_id: bodyOfWorkId,
+                task_id: taskId,
+                phase,
+                order_index: orderIndex
+            });
+        },
+        async removeTaskFromBodyOfWork(taskId) {
+            return proxy('remove_task_from_body_of_work', { task_id: taskId });
+        },
+        async activateBodyOfWork(bodyOfWorkId) {
+            return proxy('activate_body_of_work', { body_of_work_id: bodyOfWorkId });
+        },
+        async addTaskDependency(bodyOfWorkId, taskId, dependsOnTaskId) {
+            return proxy('add_task_dependency', {
+                body_of_work_id: bodyOfWorkId,
+                task_id: taskId,
+                depends_on_task_id: dependsOnTaskId
+            });
+        },
+        async removeTaskDependency(taskId, dependsOnTaskId) {
+            return proxy('remove_task_dependency', {
+                task_id: taskId,
+                depends_on_task_id: dependsOnTaskId
+            });
+        },
+        async getTaskDependencies(params) {
+            return proxy('get_task_dependencies', params);
+        },
+        async getNextBodyOfWorkTask(bodyOfWorkId) {
+            return proxy('get_next_body_of_work_task', { body_of_work_id: bodyOfWorkId });
+        }
+    };
+}

package/dist/api-client/chat.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Chat API Methods
+ *
+ * Methods for project chat:
+ * - sendProjectMessage: Send a message to the project chat channel
+ * - getProjectMessages: Read recent messages from the project chat channel
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface ChatMethods {
+    sendProjectMessage(projectId: string, message: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        message_id: string;
+        sent_at: string;
+    }>>;
+    getProjectMessages(projectId: string, limit?: number): Promise<ApiResponse<{
+        messages: Array<{
+            id: string;
+            sender_type: string;
+            sender_name: string | null;
+            content: string;
+            created_at: string;
+        }>;
+        count: number;
+    }>>;
+}
+export declare function createChatMethods(proxy: ProxyFn): ChatMethods;

package/dist/api-client/chat.js

@@ -0,0 +1,20 @@
+/**
+ * Chat API Methods
+ *
+ * Methods for project chat:
+ * - sendProjectMessage: Send a message to the project chat channel
+ * - getProjectMessages: Read recent messages from the project chat channel
+ */
+export function createChatMethods(proxy) {
+    return {
+        async sendProjectMessage(projectId, message, sessionId) {
+            return proxy('send_project_message', { project_id: projectId, message }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async getProjectMessages(projectId, limit) {
+            return proxy('get_project_messages', {
+                project_id: projectId,
+                ...(limit !== undefined && { limit }),
+            });
+        },
+    };
+}

package/dist/api-client/connectors.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Connectors API Methods
+ *
+ * Methods for external integrations (Slack, Discord, webhooks, etc.):
+ * - getConnectors: List connectors for a project
+ * - getConnector: Get a single connector
+ * - addConnector: Add a new connector
+ * - updateConnector: Update connector configuration
+ * - deleteConnector: Delete a connector
+ * - testConnector: Send a test event to a connector
+ * - getConnectorEvents: Get event history for a connector
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface ConnectorsMethods {
+    getConnectors(projectId: string, params?: {
+        type?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        connectors: Array<{
+            id: string;
+            name: string;
+            type: string;
+            description?: string;
+            status: string;
+            events: Record<string, boolean>;
+            events_sent: number;
+            last_triggered_at?: string;
+            last_error?: string;
+            last_error_at?: string;
+            created_at: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    getConnector(connectorId: string): Promise<ApiResponse<{
+        connector: {
+            id: string;
+            name: string;
+            type: string;
+            description?: string;
+            config: Record<string, unknown>;
+            events: Record<string, boolean>;
+            status: string;
+            events_sent: number;
+            last_triggered_at?: string;
+            last_error?: string;
+            last_error_at?: string;
+            created_at: string;
+        };
+    }>>;
+    addConnector(projectId: string, params: {
+        name: string;
+        type: string;
+        description?: string;
+        config?: Record<string, unknown>;
+        events?: Record<string, boolean>;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        connector_id: string;
+    }>>;
+    updateConnector(connectorId: string, updates: {
+        name?: string;
+        description?: string;
+        config?: Record<string, unknown>;
+        events?: Record<string, boolean>;
+        status?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        connector_id: string;
+    }>>;
+    deleteConnector(connectorId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    testConnector(connectorId: string): Promise<ApiResponse<{
+        success: boolean;
+        event_id: string;
+        status?: number;
+        error?: string;
+    }>>;
+    getConnectorEvents(params: {
+        connector_id?: string;
+        project_id?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        events: Array<{
+            id: string;
+            connector_id: string;
+            event_type: string;
+            status: string;
+            response_status?: number;
+            error_message?: string;
+            attempts: number;
+            created_at: string;
+            sent_at?: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+}
+export declare function createConnectorsMethods(proxy: ProxyFn): ConnectorsMethods;

package/dist/api-client/connectors.js

@@ -0,0 +1,46 @@
+/**
+ * Connectors API Methods
+ *
+ * Methods for external integrations (Slack, Discord, webhooks, etc.):
+ * - getConnectors: List connectors for a project
+ * - getConnector: Get a single connector
+ * - addConnector: Add a new connector
+ * - updateConnector: Update connector configuration
+ * - deleteConnector: Delete a connector
+ * - testConnector: Send a test event to a connector
+ * - getConnectorEvents: Get event history for a connector
+ */
+export function createConnectorsMethods(proxy) {
+    return {
+        async getConnectors(projectId, params) {
+            return proxy('get_connectors', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getConnector(connectorId) {
+            return proxy('get_connector', { connector_id: connectorId });
+        },
+        async addConnector(projectId, params) {
+            return proxy('add_connector', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async updateConnector(connectorId, updates) {
+            return proxy('update_connector', {
+                connector_id: connectorId,
+                ...updates
+            });
+        },
+        async deleteConnector(connectorId) {
+            return proxy('delete_connector', { connector_id: connectorId });
+        },
+        async testConnector(connectorId) {
+            return proxy('test_connector', { connector_id: connectorId });
+        },
+        async getConnectorEvents(params) {
+            return proxy('get_connector_events', params);
+        }
+    };
+}

package/dist/api-client/deployment.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Deployment API Methods
+ *
+ * Methods for deployment management:
+ * - requestDeployment: Request a new deployment
+ * - checkDeploymentStatus: Check active deployment status
+ * - claimDeploymentValidation: Claim a deployment for validation
+ * - reportValidation: Report build/test results
+ * - startDeployment: Start a ready deployment
+ * - completeDeployment: Mark deployment complete
+ * - cancelDeployment: Cancel active deployment
+ * - addDeploymentRequirement: Add a pre-deployment requirement
+ * - getDeploymentRequirements: Get pending requirements
+ * - getDeploymentRequirementsStats: Get requirement statistics
+ * - completeDeploymentRequirement: Mark a requirement as done
+ * - reorderDeploymentRequirements: Reorder requirements within a stage
+ * - scheduleDeployment: Schedule a deployment
+ * - getScheduledDeployments: Get scheduled deployments
+ * - updateScheduledDeployment: Update a scheduled deployment
+ * - deleteScheduledDeployment: Delete a scheduled deployment
+ * - triggerScheduledDeployment: Manually trigger a scheduled deployment
+ * - checkDueDeployments: Check for due scheduled deployments
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface DeploymentMethods {
+    requestDeployment(projectId: string, params?: {
+        environment?: string;
+        version_bump?: string;
+        git_ref?: string;
+        notes?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id: string;
+        status: string;
+    }>>;
+    checkDeploymentStatus(projectId: string): Promise<ApiResponse<{
+        active_deployment: boolean;
+        deployment?: {
+            id: string;
+            status: string;
+            environment: string;
+            git_ref?: string;
+            created_at: string;
+        };
+    }>>;
+    claimDeploymentValidation(projectId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id: string;
+        message: string;
+    }>>;
+    reportValidation(projectId: string, params: {
+        build_passed: boolean;
+        tests_passed: boolean;
+        error_message?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id: string;
+        status: string;
+    }>>;
+    startDeployment(projectId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id: string;
+        instructions: string;
+    }>>;
+    completeDeployment(projectId: string, params: {
+        success: boolean;
+        summary?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id: string;
+        status: string;
+    }>>;
+    cancelDeployment(projectId: string, reason?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    addDeploymentRequirement(projectId: string, params: {
+        type: string;
+        title: string;
+        description?: string;
+        file_path?: string;
+        stage?: string;
+        blocking?: boolean;
+        recurring?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        requirement_id: string;
+    }>>;
+    getDeploymentRequirements(projectId: string, params?: {
+        status?: string;
+        stage?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        requirements: Array<{
+            id: string;
+            type: string;
+            title: string;
+            description?: string;
+            status: string;
+            stage: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    getDeploymentRequirementsStats(projectId: string): Promise<ApiResponse<{
+        total: number;
+        by_status: Record<string, number>;
+        by_stage: Record<string, number>;
+        by_type: Record<string, number>;
+    }>>;
+    completeDeploymentRequirement(requirementId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    reorderDeploymentRequirements(projectId: string, params: {
+        stage: string;
+        requirement_ids: string[];
+    }): Promise<ApiResponse<{
+        success: boolean;
+        reordered: number;
+    }>>;
+    scheduleDeployment(projectId: string, params: {
+        scheduled_at: string;
+        schedule_type?: string;
+        environment?: string;
+        version_bump?: string;
+        auto_trigger?: boolean;
+        hours_interval?: number;
+        notes?: string;
+        git_ref?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        schedule_id: string;
+    }>>;
+    getScheduledDeployments(projectId: string, params?: {
+        includeDisabled?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        schedules: Array<{
+            id: string;
+            scheduled_at: string;
+            schedule_type: string;
+            hours_interval: number;
+            environment: string;
+            version_bump: string;
+            auto_trigger: boolean;
+            enabled: boolean;
+            git_ref?: string;
+            notes?: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    updateScheduledDeployment(scheduleId: string, updates: {
+        scheduled_at?: string;
+        schedule_type?: string;
+        hours_interval?: number;
+        environment?: string;
+        version_bump?: string;
+        auto_trigger?: boolean;
+        enabled?: boolean;
+        git_ref?: string;
+        notes?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        schedule_id: string;
+    }>>;
+    deleteScheduledDeployment(scheduleId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    triggerScheduledDeployment(scheduleId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        deployment_id?: string;
+        schedule_id: string;
+        schedule_type: string;
+        next_scheduled_at?: string;
+        message?: string;
+    }>>;
+    checkDueDeployments(projectId: string): Promise<ApiResponse<{
+        due_schedules: Array<{
+            id: string;
+            scheduled_at: string;
+            environment: string;
+            version_bump: string;
+            schedule_type: string;
+        }>;
+        count: number;
+    }>>;
+}
+export declare function createDeploymentMethods(proxy: ProxyFn): DeploymentMethods;