@vibescope/mcp-server 0.4.3 → 0.4.5

package/dist/api-client/index.js

@@ -19,6 +19,17 @@ import { createFindingsMethods } from './findings.js';
 import { createMilestonesMethods } from './milestones.js';
 import { createValidationMethods } from './validation.js';
 import { createFallbackMethods } from './fallback.js';
+import { createRequestsMethods } from './requests.js';
+import { createDeploymentMethods } from './deployment.js';
+import { createOrganizationsMethods } from './organizations.js';
+import { createBodiesOfWorkMethods } from './bodies-of-work.js';
+import { createGitIssuesMethods } from './git-issues.js';
+import { createFileCheckoutsMethods } from './file-checkouts.js';
+import { createConnectorsMethods } from './connectors.js';
+import { createSprintsMethods } from './sprints.js';
+import { createSubtasksMethods } from './subtasks.js';
+import { createProgressMethods } from './progress.js';
+import { createChatMethods } from './chat.js';
 const DEFAULT_API_URL = 'https://vibescope.dev';
 // Retry configuration defaults
 const DEFAULT_RETRY_STATUS_CODES = [429, 503, 504];
@@ -60,6 +71,17 @@ export class VibescopeApiClient {
     milestonesMethods;
     validationMethods;
     fallbackMethods;
+    requestsMethods;
+    deploymentMethods;
+    organizationsMethods;
+    bodiesOfWorkMethods;
+    gitIssuesMethods;
+    fileCheckoutsMethods;
+    connectorsMethods;
+    sprintsMethods;
+    subtasksMethods;
+    progressMethods;
+    chatMethods;
     constructor(config) {
         this.apiKey = config.apiKey;
         this.baseUrl = config.baseUrl || process.env.VIBESCOPE_API_URL || DEFAULT_API_URL;
@@ -87,6 +109,17 @@ export class VibescopeApiClient {
         this.milestonesMethods = createMilestonesMethods(proxy);
         this.validationMethods = createValidationMethods(proxy);
         this.fallbackMethods = createFallbackMethods(proxy);
+        this.requestsMethods = createRequestsMethods(proxy);
+        this.deploymentMethods = createDeploymentMethods(proxy);
+        this.organizationsMethods = createOrganizationsMethods(proxy);
+        this.bodiesOfWorkMethods = createBodiesOfWorkMethods(proxy);
+        this.gitIssuesMethods = createGitIssuesMethods(proxy);
+        this.fileCheckoutsMethods = createFileCheckoutsMethods(proxy);
+        this.connectorsMethods = createConnectorsMethods(proxy);
+        this.sprintsMethods = createSprintsMethods(proxy);
+        this.subtasksMethods = createSubtasksMethods(proxy);
+        this.progressMethods = createProgressMethods(request, proxy);
+        this.chatMethods = createChatMethods(proxy);
     }
     async request(method, path, body) {
         const url = `${this.baseUrl}${path}`;
@@ -282,6 +315,121 @@ export class VibescopeApiClient {
     // ============================================================================
     startFallbackActivity = (projectId, activity, sessionId) => this.fallbackMethods.startFallbackActivity(projectId, activity, sessionId);
     stopFallbackActivity = (projectId, summary, sessionId) => this.fallbackMethods.stopFallbackActivity(projectId, summary, sessionId);
+    // ============================================================================
+    // Requests methods (delegated)
+    // ============================================================================
+    getPendingRequests = (projectId, sessionId, limit, offset) => this.requestsMethods.getPendingRequests(projectId, sessionId, limit, offset);
+    acknowledgeRequest = (requestId, sessionId) => this.requestsMethods.acknowledgeRequest(requestId, sessionId);
+    answerQuestion = (requestId, answer, sessionId) => this.requestsMethods.answerQuestion(requestId, answer, sessionId);
+    // ============================================================================
+    // Deployment methods (delegated)
+    // ============================================================================
+    requestDeployment = (projectId, params, sessionId) => this.deploymentMethods.requestDeployment(projectId, params, sessionId);
+    checkDeploymentStatus = (projectId) => this.deploymentMethods.checkDeploymentStatus(projectId);
+    claimDeploymentValidation = (projectId, sessionId) => this.deploymentMethods.claimDeploymentValidation(projectId, sessionId);
+    reportValidation = (projectId, params) => this.deploymentMethods.reportValidation(projectId, params);
+    startDeployment = (projectId, sessionId) => this.deploymentMethods.startDeployment(projectId, sessionId);
+    completeDeployment = (projectId, params) => this.deploymentMethods.completeDeployment(projectId, params);
+    cancelDeployment = (projectId, reason) => this.deploymentMethods.cancelDeployment(projectId, reason);
+    addDeploymentRequirement = (projectId, params) => this.deploymentMethods.addDeploymentRequirement(projectId, params);
+    getDeploymentRequirements = (projectId, params) => this.deploymentMethods.getDeploymentRequirements(projectId, params);
+    getDeploymentRequirementsStats = (projectId) => this.deploymentMethods.getDeploymentRequirementsStats(projectId);
+    completeDeploymentRequirement = (requirementId) => this.deploymentMethods.completeDeploymentRequirement(requirementId);
+    reorderDeploymentRequirements = (projectId, params) => this.deploymentMethods.reorderDeploymentRequirements(projectId, params);
+    scheduleDeployment = (projectId, params) => this.deploymentMethods.scheduleDeployment(projectId, params);
+    getScheduledDeployments = (projectId, params) => this.deploymentMethods.getScheduledDeployments(projectId, params);
+    updateScheduledDeployment = (scheduleId, updates) => this.deploymentMethods.updateScheduledDeployment(scheduleId, updates);
+    deleteScheduledDeployment = (scheduleId) => this.deploymentMethods.deleteScheduledDeployment(scheduleId);
+    triggerScheduledDeployment = (scheduleId, sessionId) => this.deploymentMethods.triggerScheduledDeployment(scheduleId, sessionId);
+    checkDueDeployments = (projectId) => this.deploymentMethods.checkDueDeployments(projectId);
+    // ============================================================================
+    // Organizations methods (delegated)
+    // ============================================================================
+    listOrganizations = () => this.organizationsMethods.listOrganizations();
+    createOrganization = (params) => this.organizationsMethods.createOrganization(params);
+    updateOrganization = (organizationId, updates) => this.organizationsMethods.updateOrganization(organizationId, updates);
+    deleteOrganization = (organizationId) => this.organizationsMethods.deleteOrganization(organizationId);
+    listOrgMembers = (organizationId) => this.organizationsMethods.listOrgMembers(organizationId);
+    inviteMember = (organizationId, email, role) => this.organizationsMethods.inviteMember(organizationId, email, role);
+    updateMemberRole = (organizationId, userId, role) => this.organizationsMethods.updateMemberRole(organizationId, userId, role);
+    removeMember = (organizationId, userId) => this.organizationsMethods.removeMember(organizationId, userId);
+    leaveOrganization = (organizationId) => this.organizationsMethods.leaveOrganization(organizationId);
+    shareProjectWithOrg = (projectId, organizationId, permission) => this.organizationsMethods.shareProjectWithOrg(projectId, organizationId, permission);
+    unshareProject = (projectId, organizationId) => this.organizationsMethods.unshareProject(projectId, organizationId);
+    updateProjectShare = (projectId, organizationId, permission) => this.organizationsMethods.updateProjectShare(projectId, organizationId, permission);
+    listProjectShares = (projectId) => this.organizationsMethods.listProjectShares(projectId);
+    // ============================================================================
+    // Bodies of work methods (delegated)
+    // ============================================================================
+    createBodyOfWork = (projectId, params) => this.bodiesOfWorkMethods.createBodyOfWork(projectId, params);
+    getBodyOfWork = (bodyOfWorkId) => this.bodiesOfWorkMethods.getBodyOfWork(bodyOfWorkId);
+    getBodiesOfWork = (projectId, params) => this.bodiesOfWorkMethods.getBodiesOfWork(projectId, params);
+    updateBodyOfWork = (bodyOfWorkId, updates) => this.bodiesOfWorkMethods.updateBodyOfWork(bodyOfWorkId, updates);
+    deleteBodyOfWork = (bodyOfWorkId) => this.bodiesOfWorkMethods.deleteBodyOfWork(bodyOfWorkId);
+    addTaskToBodyOfWork = (bodyOfWorkId, taskId, phase, orderIndex) => this.bodiesOfWorkMethods.addTaskToBodyOfWork(bodyOfWorkId, taskId, phase, orderIndex);
+    removeTaskFromBodyOfWork = (taskId) => this.bodiesOfWorkMethods.removeTaskFromBodyOfWork(taskId);
+    activateBodyOfWork = (bodyOfWorkId) => this.bodiesOfWorkMethods.activateBodyOfWork(bodyOfWorkId);
+    addTaskDependency = (bodyOfWorkId, taskId, dependsOnTaskId) => this.bodiesOfWorkMethods.addTaskDependency(bodyOfWorkId, taskId, dependsOnTaskId);
+    removeTaskDependency = (taskId, dependsOnTaskId) => this.bodiesOfWorkMethods.removeTaskDependency(taskId, dependsOnTaskId);
+    getTaskDependencies = (params) => this.bodiesOfWorkMethods.getTaskDependencies(params);
+    getNextBodyOfWorkTask = (bodyOfWorkId) => this.bodiesOfWorkMethods.getNextBodyOfWorkTask(bodyOfWorkId);
+    // ============================================================================
+    // Git issues methods (delegated)
+    // ============================================================================
+    addGitIssue = (projectId, params, sessionId) => this.gitIssuesMethods.addGitIssue(projectId, params, sessionId);
+    resolveGitIssue = (gitIssueId, params, sessionId) => this.gitIssuesMethods.resolveGitIssue(gitIssueId, params, sessionId);
+    getGitIssues = (projectId, params) => this.gitIssuesMethods.getGitIssues(projectId, params);
+    deleteGitIssue = (gitIssueId) => this.gitIssuesMethods.deleteGitIssue(gitIssueId);
+    // ============================================================================
+    // File checkouts methods (delegated)
+    // ============================================================================
+    checkoutFile = (projectId, filePath, reason, sessionId) => this.fileCheckoutsMethods.checkoutFile(projectId, filePath, reason, sessionId);
+    checkinFile = (params, sessionId) => this.fileCheckoutsMethods.checkinFile(params, sessionId);
+    getFileCheckouts = (projectId, options) => this.fileCheckoutsMethods.getFileCheckouts(projectId, options);
+    abandonCheckout = (params) => this.fileCheckoutsMethods.abandonCheckout(params);
+    getFileCheckoutsStats = (projectId) => this.fileCheckoutsMethods.getFileCheckoutsStats(projectId);
+    isFileAvailable = (projectId, filePath) => this.fileCheckoutsMethods.isFileAvailable(projectId, filePath);
+    // ============================================================================
+    // Connectors methods (delegated)
+    // ============================================================================
+    getConnectors = (projectId, params) => this.connectorsMethods.getConnectors(projectId, params);
+    getConnector = (connectorId) => this.connectorsMethods.getConnector(connectorId);
+    addConnector = (projectId, params) => this.connectorsMethods.addConnector(projectId, params);
+    updateConnector = (connectorId, updates) => this.connectorsMethods.updateConnector(connectorId, updates);
+    deleteConnector = (connectorId) => this.connectorsMethods.deleteConnector(connectorId);
+    testConnector = (connectorId) => this.connectorsMethods.testConnector(connectorId);
+    getConnectorEvents = (params) => this.connectorsMethods.getConnectorEvents(params);
+    // ============================================================================
+    // Sprints methods (delegated)
+    // ============================================================================
+    createSprint = (projectId, params) => this.sprintsMethods.createSprint(projectId, params);
+    updateSprint = (sprintId, updates) => this.sprintsMethods.updateSprint(sprintId, updates);
+    getSprint = (sprintId, summaryOnly) => this.sprintsMethods.getSprint(sprintId, summaryOnly);
+    getSprints = (projectId, params) => this.sprintsMethods.getSprints(projectId, params);
+    deleteSprint = (sprintId) => this.sprintsMethods.deleteSprint(sprintId);
+    startSprint = (sprintId) => this.sprintsMethods.startSprint(sprintId);
+    completeSprint = (sprintId, params) => this.sprintsMethods.completeSprint(sprintId, params);
+    addTaskToSprint = (sprintId, taskId, params) => this.sprintsMethods.addTaskToSprint(sprintId, taskId, params);
+    removeTaskFromSprint = (sprintId, taskId) => this.sprintsMethods.removeTaskFromSprint(sprintId, taskId);
+    getSprintBacklog = (projectId, sprintId, params) => this.sprintsMethods.getSprintBacklog(projectId, sprintId, params);
+    getSprintVelocity = (projectId, limit) => this.sprintsMethods.getSprintVelocity(projectId, limit);
+    // ============================================================================
+    // Subtasks methods (delegated)
+    // ============================================================================
+    addSubtask = (parentTaskId, params, sessionId) => this.subtasksMethods.addSubtask(parentTaskId, params, sessionId);
+    getSubtasks = (parentTaskId, status) => this.subtasksMethods.getSubtasks(parentTaskId, status);
+    // ============================================================================
+    // Progress methods (delegated)
+    // ============================================================================
+    logProgress = (projectId, params) => this.progressMethods.logProgress(projectId, params);
+    getActivityFeed = (projectId, params) => this.progressMethods.getActivityFeed(projectId, params);
+    getActivityHistory = (projectId, params) => this.progressMethods.getActivityHistory(projectId, params);
+    getActivitySchedules = (projectId, params) => this.progressMethods.getActivitySchedules(projectId, params);
+    // ============================================================================
+    // Chat methods (delegated)
+    // ============================================================================
+    sendProjectMessage = (projectId, message, sessionId) => this.chatMethods.sendProjectMessage(projectId, message, sessionId);
+    getProjectMessages = (projectId, limit) => this.chatMethods.getProjectMessages(projectId, limit);
 }
 // Singleton instance
 let apiClient = null;

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

@@ -0,0 +1,101 @@
+/**
+ * Organizations API Methods
+ *
+ * Methods for organization management:
+ * - listOrganizations: List user's organizations
+ * - createOrganization: Create a new organization
+ * - updateOrganization: Update organization details
+ * - deleteOrganization: Delete an organization
+ * - listOrgMembers: List organization members
+ * - inviteMember: Invite a user to an organization
+ * - updateMemberRole: Change a member's role
+ * - removeMember: Remove a member
+ * - leaveOrganization: Leave an organization
+ * - shareProjectWithOrg: Share a project with an organization
+ * - unshareProject: Remove a project share
+ * - updateProjectShare: Update project share permission
+ * - listProjectShares: List project shares
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface OrganizationsMethods {
+    listOrganizations(): Promise<ApiResponse<{
+        organizations: Array<{
+            id: string;
+            name: string;
+            slug: string;
+            description?: string;
+            role: string;
+        }>;
+    }>>;
+    createOrganization(params: {
+        name: string;
+        slug?: string;
+        description?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+        };
+    }>>;
+    updateOrganization(organizationId: string, updates: {
+        name?: string;
+        description?: string;
+        logo_url?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        organization_id: string;
+    }>>;
+    deleteOrganization(organizationId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    listOrgMembers(organizationId: string): Promise<ApiResponse<{
+        members: Array<{
+            user_id: string;
+            email: string;
+            role: string;
+            joined_at: string;
+        }>;
+    }>>;
+    inviteMember(organizationId: string, email: string, role?: string): Promise<ApiResponse<{
+        success: boolean;
+        invite_id: string;
+    }>>;
+    updateMemberRole(organizationId: string, userId: string, role: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    removeMember(organizationId: string, userId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    leaveOrganization(organizationId: string): Promise<ApiResponse<{
+        success: boolean;
+        message: string;
+    }>>;
+    shareProjectWithOrg(projectId: string, organizationId: string, permission?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    unshareProject(projectId: string, organizationId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    updateProjectShare(projectId: string, organizationId: string, permission: string): Promise<ApiResponse<{
+        success: boolean;
+        share: {
+            permission: string;
+        };
+    }>>;
+    listProjectShares(projectId: string): Promise<ApiResponse<{
+        shares: Array<{
+            id: string;
+            permission: string;
+            shared_at: string;
+            organization: {
+                id: string;
+                name: string;
+                slug: string;
+            };
+        }>;
+        count: number;
+    }>>;
+}
+export declare function createOrganizationsMethods(proxy: ProxyFn): OrganizationsMethods;

package/dist/api-client/organizations.js

@@ -0,0 +1,86 @@
+/**
+ * Organizations API Methods
+ *
+ * Methods for organization management:
+ * - listOrganizations: List user's organizations
+ * - createOrganization: Create a new organization
+ * - updateOrganization: Update organization details
+ * - deleteOrganization: Delete an organization
+ * - listOrgMembers: List organization members
+ * - inviteMember: Invite a user to an organization
+ * - updateMemberRole: Change a member's role
+ * - removeMember: Remove a member
+ * - leaveOrganization: Leave an organization
+ * - shareProjectWithOrg: Share a project with an organization
+ * - unshareProject: Remove a project share
+ * - updateProjectShare: Update project share permission
+ * - listProjectShares: List project shares
+ */
+export function createOrganizationsMethods(proxy) {
+    return {
+        async listOrganizations() {
+            return proxy('list_organizations', {});
+        },
+        async createOrganization(params) {
+            return proxy('create_organization', params);
+        },
+        async updateOrganization(organizationId, updates) {
+            return proxy('update_organization', {
+                organization_id: organizationId,
+                ...updates
+            });
+        },
+        async deleteOrganization(organizationId) {
+            return proxy('delete_organization', { organization_id: organizationId });
+        },
+        async listOrgMembers(organizationId) {
+            return proxy('list_org_members', { organization_id: organizationId });
+        },
+        async inviteMember(organizationId, email, role) {
+            return proxy('invite_member', {
+                organization_id: organizationId,
+                email,
+                role
+            });
+        },
+        async updateMemberRole(organizationId, userId, role) {
+            return proxy('update_member_role', {
+                organization_id: organizationId,
+                user_id: userId,
+                role
+            });
+        },
+        async removeMember(organizationId, userId) {
+            return proxy('remove_member', {
+                organization_id: organizationId,
+                user_id: userId
+            });
+        },
+        async leaveOrganization(organizationId) {
+            return proxy('leave_organization', { organization_id: organizationId });
+        },
+        async shareProjectWithOrg(projectId, organizationId, permission) {
+            return proxy('share_project_with_org', {
+                project_id: projectId,
+                organization_id: organizationId,
+                permission
+            });
+        },
+        async unshareProject(projectId, organizationId) {
+            return proxy('unshare_project', {
+                project_id: projectId,
+                organization_id: organizationId
+            });
+        },
+        async updateProjectShare(projectId, organizationId, permission) {
+            return proxy('update_project_share', {
+                project_id: projectId,
+                organization_id: organizationId,
+                permission
+            });
+        },
+        async listProjectShares(projectId) {
+            return proxy('list_project_shares', { project_id: projectId });
+        }
+    };
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Progress API Methods
+ *
+ * Methods for progress tracking and activity feeds:
+ * - logProgress: Log a progress update for a project
+ * - getActivityFeed: Get combined activity feed
+ * - getActivityHistory: Get background activity history
+ * - getActivitySchedules: Get background activity schedules
+ */
+import type { ApiResponse, RequestFn, ProxyFn } from './types.js';
+export interface ProgressMethods {
+    logProgress(projectId: string, params: {
+        summary: string;
+        details?: string;
+        task_id?: string;
+        session_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        progress_id: string;
+    }>>;
+    getActivityFeed(projectId: string, params?: {
+        limit?: number;
+        since?: string;
+        types?: string[];
+        created_by?: string;
+    }): Promise<ApiResponse<{
+        activities: Array<{
+            type: string;
+            data: unknown;
+            timestamp: string;
+        }>;
+    }>>;
+    getActivityHistory(projectId: string, params?: {
+        activity_type?: string;
+        limit?: number;
+    }): Promise<ApiResponse<{
+        history: Array<{
+            id: string;
+            activity_type: string;
+            completed_at: string;
+            summary?: string;
+        }>;
+        latest_by_type: Record<string, unknown>;
+        count: number;
+    }>>;
+    getActivitySchedules(projectId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        schedules: Array<{
+            id: string;
+            activity_type: string;
+            schedule_type: string;
+            next_run_at?: string;
+            enabled: boolean;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+}
+export declare function createProgressMethods(request: RequestFn, proxy: ProxyFn): ProgressMethods;

package/dist/api-client/progress.js

@@ -0,0 +1,34 @@
+/**
+ * Progress API Methods
+ *
+ * Methods for progress tracking and activity feeds:
+ * - logProgress: Log a progress update for a project
+ * - getActivityFeed: Get combined activity feed
+ * - getActivityHistory: Get background activity history
+ * - getActivitySchedules: Get background activity schedules
+ */
+export function createProgressMethods(request, proxy) {
+    return {
+        async logProgress(projectId, params) {
+            return request('POST', `/api/mcp/projects/${projectId}/progress`, params);
+        },
+        async getActivityFeed(projectId, params) {
+            return proxy('get_activity_feed', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getActivityHistory(projectId, params) {
+            return proxy('get_activity_history', {
+                project_id: projectId,
+                ...params
+            });
+        },
+        async getActivitySchedules(projectId, params) {
+            return proxy('get_activity_schedules', {
+                project_id: projectId,
+                ...params
+            });
+        }
+    };
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Requests API Methods
+ *
+ * Methods for user request handling:
+ * - getPendingRequests: Get unacknowledged requests for a project
+ * - acknowledgeRequest: Mark a request as handled
+ * - answerQuestion: Answer a question from the user
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface RequestsMethods {
+    getPendingRequests(projectId: string, sessionId?: string, limit?: number, offset?: number): Promise<ApiResponse<{
+        requests: Array<{
+            id: string;
+            request_type: string;
+            message: string;
+            created_at: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    acknowledgeRequest(requestId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    answerQuestion(requestId: string, answer: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+}
+export declare function createRequestsMethods(proxy: ProxyFn): RequestsMethods;

package/dist/api-client/requests.js

@@ -0,0 +1,28 @@
+/**
+ * Requests API Methods
+ *
+ * Methods for user request handling:
+ * - getPendingRequests: Get unacknowledged requests for a project
+ * - acknowledgeRequest: Mark a request as handled
+ * - answerQuestion: Answer a question from the user
+ */
+export function createRequestsMethods(proxy) {
+    return {
+        async getPendingRequests(projectId, sessionId, limit, offset) {
+            return proxy('get_pending_requests', {
+                project_id: projectId,
+                ...(limit !== undefined && { limit }),
+                ...(offset !== undefined && { offset }),
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async acknowledgeRequest(requestId, sessionId) {
+            return proxy('acknowledge_request', { request_id: requestId }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async answerQuestion(requestId, answer, sessionId) {
+            return proxy('answer_question', {
+                request_id: requestId,
+                answer
+            }, sessionId ? { session_id: sessionId } : undefined);
+        }
+    };
+}

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

@@ -0,0 +1,153 @@
+/**
+ * Sprints API Methods
+ *
+ * Methods for sprint management:
+ * - createSprint: Create a new sprint
+ * - updateSprint: Update sprint details
+ * - getSprint: Get a sprint with tasks
+ * - getSprints: List sprints for a project
+ * - deleteSprint: Delete a sprint
+ * - startSprint: Activate a sprint
+ * - completeSprint: Complete a sprint
+ * - addTaskToSprint: Add a task to a sprint
+ * - removeTaskFromSprint: Remove a task from a sprint
+ * - getSprintBacklog: Get tasks available to add to a sprint
+ * - getSprintVelocity: Get velocity metrics for completed sprints
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface SprintsMethods {
+    createSprint(projectId: string, params: {
+        title: string;
+        start_date: string;
+        end_date: string;
+        goal?: string;
+        auto_deploy_on_completion?: boolean;
+        deploy_environment?: string;
+        deploy_version_bump?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        sprint_id: string;
+        sprint_number: number;
+    }>>;
+    updateSprint(sprintId: string, updates: {
+        title?: string;
+        goal?: string;
+        start_date?: string;
+        end_date?: string;
+        auto_deploy_on_completion?: boolean;
+        deploy_environment?: string;
+        deploy_version_bump?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getSprint(sprintId: string, summaryOnly?: boolean): Promise<ApiResponse<{
+        id: string;
+        title: string;
+        goal?: string;
+        sprint_number: number;
+        sprint_status: string;
+        start_date: string;
+        end_date: string;
+        progress_percentage: number;
+        velocity_points: number;
+        committed_points: number;
+        pre_tasks?: unknown[];
+        core_tasks?: unknown[];
+        post_tasks?: unknown[];
+        total_tasks?: number;
+        task_counts?: {
+            pre: {
+                total: number;
+                completed: number;
+            };
+            core: {
+                total: number;
+                completed: number;
+            };
+            post: {
+                total: number;
+                completed: number;
+            };
+            total: number;
+            completed: number;
+            in_progress: number;
+        };
+        next_task?: {
+            id: string;
+            title: string;
+            priority: number;
+            phase: string;
+        } | null;
+    }>>;
+    getSprints(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        sprints: Array<{
+            id: string;
+            title: string;
+            sprint_number: number;
+            sprint_status: string;
+            start_date: string;
+            end_date: string;
+            progress_percentage: number;
+            velocity_points: number;
+            committed_points: number;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    deleteSprint(sprintId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    startSprint(sprintId: string): Promise<ApiResponse<{
+        success: boolean;
+        sprint_id: string;
+        status: string;
+    }>>;
+    completeSprint(sprintId: string, params?: {
+        retrospective_notes?: string;
+        skip_retrospective?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        sprint_id: string;
+        status: string;
+    }>>;
+    addTaskToSprint(sprintId: string, taskId: string, params?: {
+        story_points?: number;
+        phase?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    removeTaskFromSprint(sprintId: string, taskId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getSprintBacklog(projectId: string, sprintId?: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            priority: number;
+            status: string;
+            estimated_minutes?: number;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    getSprintVelocity(projectId: string, limit?: number): Promise<ApiResponse<{
+        sprints: Array<{
+            sprint_id: string;
+            sprint_number: number;
+            title: string;
+            committed_points: number;
+            velocity_points: number;
+            completion_rate: number;
+        }>;
+        average_velocity: number;
+        total_sprints: number;
+    }>>;
+}
+export declare function createSprintsMethods(proxy: ProxyFn): SprintsMethods;