@vibescope/mcp-server 0.0.1 → 0.1.0

package/dist/api-client.d.ts

@@ -0,0 +1,1114 @@
+/**
+ * Vibescope API Client
+ *
+ * HTTP client for communicating with the Vibescope API.
+ * All database operations are handled server-side through these endpoints.
+ */
+interface ApiClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface ApiResponse<T> {
+    ok: boolean;
+    status: number;
+    data?: T;
+    error?: string;
+}
+export declare class VibescopeApiClient {
+    private apiKey;
+    private baseUrl;
+    constructor(config: ApiClientConfig);
+    private request;
+    validateAuth(): Promise<ApiResponse<{
+        valid: boolean;
+        user_id: string;
+        api_key_id: string;
+        key_name: string;
+    }>>;
+    startSession(params: {
+        project_id?: string;
+        git_url?: string;
+        mode?: 'lite' | 'full';
+        model?: 'opus' | 'sonnet' | 'haiku';
+        role?: 'developer' | 'validator' | 'deployer' | 'reviewer' | 'maintainer';
+    }): Promise<ApiResponse<{
+        session_started: boolean;
+        session_id?: string;
+        persona?: string;
+        role?: string;
+        project?: {
+            id: string;
+            name: string;
+            description?: string;
+            goal?: string;
+            status?: string;
+            git_url?: string;
+            agent_instructions?: string;
+            tech_stack?: string[];
+            git_workflow?: string;
+            git_main_branch?: string;
+            git_develop_branch?: string;
+            git_auto_branch?: boolean;
+        };
+        active_tasks?: Array<{
+            id: string;
+            title: string;
+            status: string;
+            priority: number;
+            progress_percentage?: number;
+            estimated_minutes?: number;
+        }>;
+        blockers?: Array<{
+            id: string;
+            description: string;
+            status: string;
+        }>;
+        next_task?: {
+            id: string;
+            title: string;
+            priority: number;
+            estimated_minutes?: number;
+        } | null;
+        directive?: string;
+        blockers_count?: number;
+        validation_count?: number;
+        project_not_found?: boolean;
+        message?: string;
+        suggestion?: {
+            action: string;
+            example: string;
+            note: string;
+        };
+        error?: string;
+    }>>;
+    heartbeat(sessionId: string): Promise<ApiResponse<{
+        success: boolean;
+        session_id: string;
+        timestamp: string;
+    }>>;
+    endSession(sessionId: string): Promise<ApiResponse<{
+        success: boolean;
+        ended_session_id?: string;
+        session_summary?: {
+            agent_name: string;
+            tasks_completed_this_session: number;
+            tasks_awaiting_validation: number;
+            tasks_released: number;
+        };
+        reminders?: string[];
+    }>>;
+    listProjects(): Promise<ApiResponse<{
+        projects: Array<{
+            id: string;
+            name: string;
+            description?: string;
+            status: string;
+            git_url?: string;
+            goal?: string;
+            tech_stack?: string[];
+        }>;
+    }>>;
+    createProject(params: {
+        name: string;
+        description?: string;
+        goal?: string;
+        git_url?: string;
+        tech_stack?: string[];
+    }): Promise<ApiResponse<{
+        success: boolean;
+        project: {
+            id: string;
+            name: string;
+        };
+    }>>;
+    getProject(projectId: string, gitUrl?: string): Promise<ApiResponse<{
+        found: boolean;
+        project?: {
+            id: string;
+            name: string;
+            description?: string;
+            goal?: string;
+            status: string;
+            git_url?: string;
+            agent_instructions?: string;
+            tech_stack?: string[];
+            git_workflow?: string;
+            git_main_branch?: string;
+            git_develop_branch?: string;
+            git_auto_branch?: boolean;
+            git_auto_tag?: boolean;
+            deployment_instructions?: string;
+        };
+        active_tasks?: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            priority: number;
+            status: string;
+            progress_percentage?: number;
+            estimated_minutes?: number;
+        }>;
+        open_blockers?: Array<{
+            id: string;
+            description: string;
+        }>;
+        recent_decisions?: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+        message?: string;
+    }>>;
+    updateProject(projectId: string, updates: {
+        name?: string;
+        description?: string;
+        goal?: string;
+        git_url?: string;
+        tech_stack?: string[];
+        status?: string;
+        git_workflow?: string;
+        git_main_branch?: string;
+        git_develop_branch?: string;
+        git_auto_branch?: boolean;
+        git_auto_tag?: boolean;
+        deployment_instructions?: string;
+        agent_instructions?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        project_id: string;
+    }>>;
+    getTasks(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+        include_subtasks?: boolean;
+        search_query?: string;
+        include_metadata?: boolean;
+    }): Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            priority: number;
+            status: string;
+            progress_percentage?: number;
+            estimated_minutes?: number;
+            started_at?: string;
+            completed_at?: string;
+            parent_task_id?: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+    }>>;
+    createTask(projectId: string, params: {
+        title: string;
+        description?: string;
+        priority?: number;
+        estimated_minutes?: number;
+        blocking?: boolean;
+        session_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        title: string;
+        blocking?: boolean;
+        message?: string;
+    }>>;
+    getNextTask(projectId: string, sessionId?: string): Promise<ApiResponse<{
+        task?: {
+            id: string;
+            title: string;
+            description?: string;
+            priority: number;
+            estimated_minutes?: number;
+            blocking?: boolean;
+        } | null;
+        blocking_task?: boolean;
+        deployment_blocks_tasks?: boolean;
+        deployment?: {
+            id: string;
+            status: string;
+            env: string;
+        };
+        awaiting_validation?: Array<{
+            id: string;
+            title: string;
+        }>;
+        validation_priority?: string;
+        all_claimed?: boolean;
+        is_subtask?: boolean;
+        suggested_activity?: string;
+        directive?: string;
+        message?: string;
+        action?: string;
+    }>>;
+    getTask(taskId: string): Promise<ApiResponse<{
+        task: {
+            id: string;
+            title: string;
+            description?: string;
+            priority: number;
+            status: string;
+            progress_percentage?: number;
+            estimated_minutes?: number;
+            started_at?: string;
+            completed_at?: string;
+            git_branch?: string;
+            blocking?: boolean;
+            references?: Array<{
+                url: string;
+                label?: string;
+            }>;
+            parent_task_id?: string;
+            working_agent_session_id?: string;
+        };
+    }>>;
+    updateTask(taskId: string, updates: {
+        title?: string;
+        description?: string;
+        priority?: number;
+        status?: string;
+        progress_percentage?: number;
+        progress_note?: string;
+        estimated_minutes?: number;
+        git_branch?: string;
+        session_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+    }>>;
+    completeTask(taskId: string, params: {
+        summary?: string;
+        session_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        directive: string;
+        auto_continue: boolean;
+        completed_task_id: string;
+        next_task?: {
+            id: string;
+            title: string;
+            priority: number;
+            estimated_minutes?: number;
+        } | null;
+        context?: {
+            validation?: number;
+            blockers?: number;
+            deployment?: string;
+        };
+        next_action: string;
+    }>>;
+    deleteTask(taskId: string): Promise<ApiResponse<{
+        success: boolean;
+        deleted_id: string;
+    }>>;
+    logProgress(projectId: string, params: {
+        summary: string;
+        details?: string;
+        task_id?: string;
+        session_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        progress_id: string;
+    }>>;
+    getGitWorkflow(projectId: string, taskId?: string): Promise<ApiResponse<{
+        workflow: string;
+        main_branch: string;
+        develop_branch?: string | null;
+        auto_branch?: boolean;
+        auto_tag?: boolean;
+        instructions: string[];
+        task?: {
+            id: string;
+            title: string;
+            current_branch?: string;
+            suggested_branch?: string | null;
+        };
+    }>>;
+    proxy<T>(operation: string, args: Record<string, unknown>, sessionContext?: {
+        session_id: string | null;
+        persona: string | null;
+        instance_id: string;
+    }): Promise<ApiResponse<T>>;
+    getBlockers(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        blockers: Array<{
+            id: string;
+            description: string;
+            status: string;
+            resolution_note?: string;
+            created_at: string;
+            resolved_at?: string;
+        }>;
+        total_count?: number;
+        has_more?: boolean;
+    }>>;
+    addBlocker(projectId: string, description: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        blocker_id: string;
+    }>>;
+    resolveBlocker(blockerId: string, resolutionNote?: string): Promise<ApiResponse<{
+        success: boolean;
+        blocker_id: string;
+    }>>;
+    deleteBlocker(blockerId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getDecisions(projectId: string): Promise<ApiResponse<{
+        decisions: Array<{
+            id: string;
+            title: string;
+            description: string;
+            rationale?: string;
+            alternatives_considered?: string[];
+            created_at: string;
+        }>;
+    }>>;
+    logDecision(projectId: string, params: {
+        title: string;
+        description: string;
+        rationale?: string;
+        alternatives_considered?: string[];
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        decision_id: string;
+    }>>;
+    deleteDecision(decisionId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getIdeas(projectId: string, params?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        ideas: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            doc_url?: string;
+            created_at: string;
+        }>;
+    }>>;
+    addIdea(projectId: string, params: {
+        title: string;
+        description?: string;
+        status?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    updateIdea(ideaId: string, updates: {
+        title?: string;
+        description?: string;
+        status?: string;
+        doc_url?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    deleteIdea(ideaId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    convertIdeaToTask(ideaId: string, params?: {
+        priority?: number;
+        estimated_minutes?: number;
+        update_status?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        task_id?: string;
+        task_title?: string;
+        idea_id?: string;
+        idea_status?: string;
+        message?: string;
+        error?: string;
+        existing_task_id?: string;
+    }>>;
+    getFindings(projectId: string, params?: {
+        category?: string;
+        severity?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<ApiResponse<{
+        findings: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            category: string;
+            severity: string;
+            status: string;
+            file_path?: string;
+            line_number?: number;
+            resolution_note?: string;
+            created_at: string;
+        }>;
+    }>>;
+    addFinding(projectId: string, params: {
+        title: string;
+        description?: string;
+        category?: string;
+        severity?: string;
+        file_path?: string;
+        line_number?: number;
+        related_task_id?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        finding_id: string;
+    }>>;
+    updateFinding(findingId: string, updates: {
+        title?: string;
+        description?: string;
+        severity?: string;
+        status?: string;
+        resolution_note?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        finding_id: string;
+    }>>;
+    deleteFinding(findingId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getMilestones(taskId: string): Promise<ApiResponse<{
+        milestones: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            order_index: number;
+            created_at: string;
+            completed_at?: string;
+        }>;
+        stats: {
+            total: number;
+            completed: number;
+            progress_percentage: number;
+        };
+    }>>;
+    addMilestone(taskId: string, params: {
+        title: string;
+        description?: string;
+        order_index?: number;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        milestone_id: string;
+    }>>;
+    updateMilestone(milestoneId: string, updates: {
+        title?: string;
+        description?: string;
+        status?: string;
+        order_index?: number;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        milestone: {
+            id: string;
+            title: string;
+            status: string;
+        };
+    }>>;
+    completeMilestone(milestoneId: string): Promise<ApiResponse<{
+        success: boolean;
+        milestone: {
+            id: string;
+            title: string;
+            status: string;
+        };
+    }>>;
+    deleteMilestone(milestoneId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getPendingRequests(projectId: string, sessionId?: string): Promise<ApiResponse<{
+        requests: Array<{
+            id: string;
+            request_type: string;
+            message: string;
+            created_at: string;
+        }>;
+    }>>;
+    acknowledgeRequest(requestId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    answerQuestion(requestId: string, answer: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getTasksAwaitingValidation(projectId: string): Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            completed_at?: string;
+            completed_by_session_id?: string;
+        }>;
+    }>>;
+    claimValidation(taskId: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+    }>>;
+    validateTask(taskId: string, params: {
+        approved: boolean;
+        validation_notes?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        approved: boolean;
+        task_id: string;
+        message?: string;
+    }>>;
+    startFallbackActivity(projectId: string, activity: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        activity: string;
+        message: string;
+    }>>;
+    stopFallbackActivity(projectId: string, summary?: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    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): Promise<ApiResponse<{
+        schedules: Array<{
+            id: string;
+            activity_type: string;
+            schedule_type: string;
+            next_run_at?: string;
+            enabled: boolean;
+        }>;
+        due_activities: string[];
+        count: number;
+    }>>;
+    addSubtask(parentTaskId: string, params: {
+        title: string;
+        description?: string;
+        priority?: number;
+        estimated_minutes?: number;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        subtask_id: string;
+        parent_task_id: string;
+    }>>;
+    getSubtasks(parentTaskId: string, status?: string): Promise<ApiResponse<{
+        subtasks: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            priority: number;
+            status: string;
+            progress_percentage?: number;
+            estimated_minutes?: number;
+        }>;
+        stats: {
+            total: number;
+            completed: number;
+            progress_percentage: number;
+        };
+    }>>;
+    getActivityFeed(projectId: string, params?: {
+        limit?: number;
+        since?: string;
+    }): Promise<ApiResponse<{
+        activities: Array<{
+            type: string;
+            data: unknown;
+            timestamp: string;
+        }>;
+    }>>;
+    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;
+    }>>;
+    addTaskReference(taskId: string, url: string, label?: string): Promise<ApiResponse<{
+        success: boolean;
+        reference: {
+            url: string;
+            label?: string;
+        };
+    }>>;
+    removeTaskReference(taskId: string, url: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    queryKnowledgeBase(projectId: string, params?: {
+        categories?: string[];
+        limit?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
+        findings?: Array<{
+            id: string;
+            title: string;
+            category: string;
+            severity: string;
+        }>;
+        decisions?: Array<{
+            id: string;
+            title: string;
+            description: string;
+        }>;
+        completed_tasks?: Array<{
+            id: string;
+            title: string;
+            completed_at: string;
+        }>;
+        resolved_blockers?: Array<{
+            id: string;
+            description: string;
+            resolution_note?: string;
+        }>;
+    }>>;
+    syncSession(sessionId: string, params?: {
+        total_tokens?: number;
+        token_breakdown?: Record<string, unknown>;
+        model_usage?: Record<string, unknown>;
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    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;
+    }>>;
+    shareProjectWithOrg(projectId: string, organizationId: string, permission?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    unshareProject(projectId: string, organizationId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    leaveOrganization(organizationId: string): Promise<ApiResponse<{
+        success: boolean;
+        message: string;
+    }>>;
+    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;
+    }>>;
+    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;
+    }>>;
+    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;
+    }): 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;
+    }>>;
+    getCostSummary(projectId: string, params?: {
+        period?: 'daily' | 'weekly' | 'monthly';
+        limit?: number;
+    }): Promise<ApiResponse<{
+        summaries: Array<{
+            date: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+        }>;
+    }>>;
+    getCostAlerts(): Promise<ApiResponse<{
+        alerts: Array<{
+            id: string;
+            threshold_amount: number;
+            threshold_period: string;
+            alert_type: string;
+            enabled: boolean;
+        }>;
+    }>>;
+    addCostAlert(params: {
+        threshold_amount: number;
+        threshold_period: 'daily' | 'weekly' | 'monthly';
+        alert_type?: 'warning' | 'critical';
+        project_id?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        alert_id: string;
+    }>>;
+    updateCostAlert(alertId: string, updates: {
+        threshold_amount?: number;
+        threshold_period?: string;
+        alert_type?: string;
+        enabled?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    deleteCostAlert(alertId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getTaskCosts(projectId: string, limit?: number): Promise<ApiResponse<{
+        task_costs: Array<{
+            task_id: string;
+            title: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+        }>;
+    }>>;
+    getTokenUsage(): Promise<ApiResponse<{
+        session_tokens: number;
+        estimated_cost: number;
+    }>>;
+    batchUpdateTasks(updates: Array<{
+        task_id: string;
+        status?: string;
+        priority?: number;
+        progress_percentage?: number;
+        progress_note?: string;
+    }>): Promise<ApiResponse<{
+        success: boolean;
+        updated_count: number;
+    }>>;
+    batchCompleteTasks(completions: Array<{
+        task_id: string;
+        summary?: string;
+    }>): Promise<ApiResponse<{
+        success: boolean;
+        completed_count: number;
+        next_task?: {
+            id: string;
+            title: string;
+        } | null;
+    }>>;
+    addDeploymentRequirement(projectId: string, params: {
+        type: string;
+        title: string;
+        description?: string;
+        file_path?: string;
+        stage?: string;
+        blocking?: boolean;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        requirement_id: string;
+    }>>;
+    getDeploymentRequirements(projectId: string, params?: {
+        status?: string;
+        stage?: string;
+    }): Promise<ApiResponse<{
+        requirements: Array<{
+            id: string;
+            type: string;
+            title: string;
+            description?: string;
+            status: string;
+            stage: string;
+        }>;
+    }>>;
+    completeDeploymentRequirement(requirementId: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    scheduleDeployment(projectId: string, params: {
+        scheduled_at: string;
+        schedule_type?: string;
+        environment?: string;
+        version_bump?: string;
+        auto_trigger?: boolean;
+        notes?: string;
+        git_ref?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        schedule_id: string;
+    }>>;
+    getScheduledDeployments(projectId: string, includeDisabled?: boolean): Promise<ApiResponse<{
+        schedules: Array<{
+            id: string;
+            scheduled_at: string;
+            schedule_type: string;
+            environment: string;
+            version_bump: string;
+            auto_trigger: boolean;
+            enabled: boolean;
+            git_ref?: string;
+            notes?: string;
+        }>;
+        count: number;
+        due_count: number;
+    }>>;
+    updateScheduledDeployment(scheduleId: string, updates: {
+        scheduled_at?: string;
+        schedule_type?: string;
+        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;
+    }>>;
+    updateProjectReadme(projectId: string, readmeContent: string): Promise<ApiResponse<{
+        success: boolean;
+        project_id: string;
+    }>>;
+}
+export declare function getApiClient(): VibescopeApiClient;
+export declare function initApiClient(config: ApiClientConfig): VibescopeApiClient;
+export {};