@vibescope/mcp-server 0.4.4 → 0.4.6

package/dist/api-client/deployment.js

@@ -0,0 +1,113 @@
+/**
+ * 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
+ */
+export function createDeploymentMethods(proxy) {
+    return {
+        async requestDeployment(projectId, params, sessionId) {
+            return proxy('request_deployment', {
+                project_id: projectId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async checkDeploymentStatus(projectId) {
+            return proxy('check_deployment_status', { project_id: projectId });
+        },
+        async claimDeploymentValidation(projectId, sessionId) {
+            return proxy('claim_deployment_validation', { project_id: projectId }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async reportValidation(projectId, params) {
+            return proxy('report_validation', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async startDeployment(projectId, sessionId) {
+            return proxy('start_deployment', { project_id: projectId }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async completeDeployment(projectId, params) {
+            return proxy('complete_deployment', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async cancelDeployment(projectId, reason) {
+            return proxy('cancel_deployment', {
+                project_id: projectId,
+                reason
+            });
+        },
+        async addDeploymentRequirement(projectId, params) {
+            return proxy('add_deployment_requirement', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getDeploymentRequirements(projectId, params) {
+            return proxy('get_deployment_requirements', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getDeploymentRequirementsStats(projectId) {
+            return proxy('get_deployment_requirements_stats', { project_id: projectId });
+        },
+        async completeDeploymentRequirement(requirementId) {
+            return proxy('complete_deployment_requirement', { requirement_id: requirementId });
+        },
+        async reorderDeploymentRequirements(projectId, params) {
+            return proxy('reorder_deployment_requirements', {
+                project_id: projectId,
+                ...params,
+            });
+        },
+        async scheduleDeployment(projectId, params) {
+            return proxy('schedule_deployment', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getScheduledDeployments(projectId, params) {
+            return proxy('get_scheduled_deployments', {
+                project_id: projectId,
+                include_disabled: params?.includeDisabled,
+                limit: params?.limit,
+                offset: params?.offset
+            });
+        },
+        async updateScheduledDeployment(scheduleId, updates) {
+            return proxy('update_scheduled_deployment', {
+                schedule_id: scheduleId,
+                ...updates
+            });
+        },
+        async deleteScheduledDeployment(scheduleId) {
+            return proxy('delete_scheduled_deployment', { schedule_id: scheduleId });
+        },
+        async triggerScheduledDeployment(scheduleId, sessionId) {
+            return proxy('trigger_scheduled_deployment', { schedule_id: scheduleId }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async checkDueDeployments(projectId) {
+            return proxy('check_due_deployments', { project_id: projectId });
+        }
+    };
+}

package/dist/api-client/file-checkouts.d.ts

@@ -0,0 +1,71 @@
+/**
+ * File Checkouts API Methods
+ *
+ * Methods for multi-agent file coordination:
+ * - checkoutFile: Check out a file for editing
+ * - checkinFile: Check in a file after editing
+ * - getFileCheckouts: Get file checkouts for a project
+ * - abandonCheckout: Force-release a checkout
+ * - getFileCheckoutsStats: Get aggregate checkout statistics
+ * - isFileAvailable: Check if a file is available for checkout
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface FileCheckoutsMethods {
+    checkoutFile(projectId: string, filePath: string, reason?: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        file_path: string;
+        already_checked_out?: boolean;
+        message: string;
+    }>>;
+    checkinFile(params: {
+        checkout_id?: string;
+        project_id?: string;
+        file_path?: string;
+        summary?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        message: string;
+    }>>;
+    getFileCheckouts(projectId: string, options?: {
+        status?: string;
+        file_path?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        checkouts: Array<{
+            id: string;
+            file_path: string;
+            status: string;
+            checked_out_at: string;
+            checkout_reason?: string;
+            checked_in_at?: string;
+            checkin_summary?: string;
+            checked_out_by?: string;
+        }>;
+    }>>;
+    abandonCheckout(params: {
+        checkout_id?: string;
+        project_id?: string;
+        file_path?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        message: string;
+    }>>;
+    getFileCheckoutsStats(projectId: string): Promise<ApiResponse<{
+        total: number;
+        by_status: Record<string, number>;
+    }>>;
+    isFileAvailable(projectId: string, filePath: string): Promise<ApiResponse<{
+        available: boolean;
+        checkout?: {
+            id: string;
+            checked_out_by?: string;
+            checked_out_at: string;
+            checkout_reason?: string;
+        };
+    }>>;
+}
+export declare function createFileCheckoutsMethods(proxy: ProxyFn): FileCheckoutsMethods;

package/dist/api-client/file-checkouts.js

@@ -0,0 +1,43 @@
+/**
+ * File Checkouts API Methods
+ *
+ * Methods for multi-agent file coordination:
+ * - checkoutFile: Check out a file for editing
+ * - checkinFile: Check in a file after editing
+ * - getFileCheckouts: Get file checkouts for a project
+ * - abandonCheckout: Force-release a checkout
+ * - getFileCheckoutsStats: Get aggregate checkout statistics
+ * - isFileAvailable: Check if a file is available for checkout
+ */
+export function createFileCheckoutsMethods(proxy) {
+    return {
+        async checkoutFile(projectId, filePath, reason, sessionId) {
+            return proxy('checkout_file', {
+                project_id: projectId,
+                file_path: filePath,
+                reason
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async checkinFile(params, sessionId) {
+            return proxy('checkin_file', params, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async getFileCheckouts(projectId, options) {
+            return proxy('get_file_checkouts', {
+                project_id: projectId,
+                ...options
+            });
+        },
+        async abandonCheckout(params) {
+            return proxy('abandon_checkout', params);
+        },
+        async getFileCheckoutsStats(projectId) {
+            return proxy('get_file_checkouts_stats', { project_id: projectId });
+        },
+        async isFileAvailable(projectId, filePath) {
+            return proxy('is_file_available', {
+                project_id: projectId,
+                file_path: filePath
+            });
+        }
+    };
+}

package/dist/api-client/git-issues.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Git Issues API Methods
+ *
+ * Methods for git issue tracking:
+ * - addGitIssue: Record a git-related issue
+ * - resolveGitIssue: Mark a git issue as resolved
+ * - getGitIssues: List git issues for a project
+ * - deleteGitIssue: Delete a git issue
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface GitIssuesMethods {
+    addGitIssue(projectId: string, params: {
+        issue_type: string;
+        branch: string;
+        target_branch?: string;
+        pr_url?: string;
+        conflicting_files?: string[];
+        error_message?: string;
+        task_id?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        git_issue_id: string;
+    }>>;
+    resolveGitIssue(gitIssueId: string, params?: {
+        resolution_note?: string;
+        auto_resolved?: boolean;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        git_issue_id: string;
+    }>>;
+    getGitIssues(projectId: string, params?: {
+        status?: string;
+        issue_type?: string;
+        branch?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        git_issues: Array<{
+            id: string;
+            issue_type: string;
+            branch: string;
+            target_branch?: string;
+            pr_url?: string;
+            conflicting_files?: string[];
+            error_message?: string;
+            status: string;
+            created_at: string;
+            resolved_at?: string;
+        }>;
+    }>>;
+    deleteGitIssue(gitIssueId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+}
+export declare function createGitIssuesMethods(proxy: ProxyFn): GitIssuesMethods;

package/dist/api-client/git-issues.js

@@ -0,0 +1,34 @@
+/**
+ * Git Issues API Methods
+ *
+ * Methods for git issue tracking:
+ * - addGitIssue: Record a git-related issue
+ * - resolveGitIssue: Mark a git issue as resolved
+ * - getGitIssues: List git issues for a project
+ * - deleteGitIssue: Delete a git issue
+ */
+export function createGitIssuesMethods(proxy) {
+    return {
+        async addGitIssue(projectId, params, sessionId) {
+            return proxy('add_git_issue', {
+                project_id: projectId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async resolveGitIssue(gitIssueId, params, sessionId) {
+            return proxy('resolve_git_issue', {
+                git_issue_id: gitIssueId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async getGitIssues(projectId, params) {
+            return proxy('get_git_issues', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async deleteGitIssue(gitIssueId) {
+            return proxy('delete_git_issue', { git_issue_id: gitIssueId });
+        }
+    };
+}