@vibescope/mcp-server 0.3.0 → 0.3.3

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

@@ -0,0 +1,749 @@
+/**
+ * Vibescope API Client
+ *
+ * HTTP client for communicating with the Vibescope API.
+ * All database operations are handled server-side through these endpoints.
+ *
+ * This module composes domain-specific API methods into a unified client.
+ */
+import type { ApiClientConfig, ApiResponse } from './types.js';
+import { type SessionMethods } from './session.js';
+import { type ProjectMethods } from './project.js';
+import { type BlockersMethods } from './blockers.js';
+import { type CostMethods } from './cost.js';
+import { type WorktreesMethods } from './worktrees.js';
+import { type DiscoveryMethods } from './discovery.js';
+import { type DecisionsMethods } from './decisions.js';
+import { type IdeasMethods } from './ideas.js';
+import { type TasksMethods } from './tasks.js';
+export type { ApiClientConfig, ApiResponse, RetryConfig, RequestFn, ProxyFn } from './types.js';
+export type { SessionMethods } from './session.js';
+export type { ProjectMethods } from './project.js';
+export type { BlockersMethods } from './blockers.js';
+export type { CostMethods } from './cost.js';
+export type { WorktreesMethods } from './worktrees.js';
+export type { DiscoveryMethods } from './discovery.js';
+export type { DecisionsMethods } from './decisions.js';
+export type { IdeasMethods } from './ideas.js';
+export type { TasksMethods } from './tasks.js';
+/**
+ * Combined interface for all API methods
+ */
+export interface VibescopeApiClientMethods extends SessionMethods, ProjectMethods, BlockersMethods, CostMethods, WorktreesMethods, DiscoveryMethods, DecisionsMethods, IdeasMethods, TasksMethods {
+}
+export declare class VibescopeApiClient implements VibescopeApiClientMethods {
+    private apiKey;
+    private baseUrl;
+    private retryConfig;
+    private sessionMethods;
+    private projectMethods;
+    private blockersMethods;
+    private costMethods;
+    private worktreesMethods;
+    private discoveryMethods;
+    private decisionsMethods;
+    private ideasMethods;
+    private tasksMethods;
+    constructor(config: ApiClientConfig);
+    private request;
+    /**
+     * Generic proxy method for operations that go through the MCP proxy endpoint
+     */
+    proxy<T>(operation: string, args: Record<string, unknown>, sessionContext?: {
+        session_id?: string;
+        project_id?: string;
+    }): Promise<ApiResponse<T>>;
+    validateAuth: () => Promise<ApiResponse<{
+        valid: boolean;
+        user_id: string;
+        api_key_id: string;
+        key_name: string;
+    }>>;
+    startSession: (params: Parameters<SessionMethods["startSession"]>[0]) => 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;
+        pending_requests?: Array<{
+            id: string;
+            request_type: string;
+            message: string;
+            created_at: string;
+        }>;
+        pending_requests_count?: number;
+        URGENT_QUESTIONS?: {
+            count: number;
+            oldest_waiting_minutes: number;
+            action_required: string;
+            requests: Array<{
+                id: string;
+                message: string;
+                waiting_minutes: number;
+            }>;
+        };
+        directive?: string;
+        blockers_count?: number;
+        validation_count?: number;
+        project_not_found?: boolean;
+        message?: string;
+        suggestion?: {
+            action: string;
+            example: string;
+            note: string;
+        };
+        agent_setup?: {
+            agent_type: string;
+            is_new_agent_type: boolean;
+            setup_required: boolean;
+            instructions: string;
+            config_file: string;
+            template_url?: string;
+            steps: string[];
+        };
+        stale_worktrees?: Array<{
+            task_id: string;
+            task_title: string;
+            worktree_path: string;
+            worktree_hostname?: string | null;
+        }>;
+        stale_worktrees_count?: number;
+        cleanup_action?: string;
+        awaiting_validation?: Array<{
+            id: string;
+            title?: string;
+        }>;
+        validation_priority?: boolean;
+        next_action?: string;
+        error?: string;
+    }>>;
+    heartbeat: (sessionId: string, options?: Parameters<SessionMethods["heartbeat"]>[1]) => 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[];
+    }>>;
+    signalIdle: (sessionId: string) => Promise<ApiResponse<{
+        success: boolean;
+        session_id: string;
+        status: string;
+        message: string;
+    }>>;
+    syncSession: (sessionId: string, params?: Parameters<SessionMethods["syncSession"]>[1]) => Promise<ApiResponse<{
+        session: {
+            id: string;
+            status: string;
+            agent_name: string;
+        };
+        project?: unknown;
+        tasks?: unknown[];
+    }>>;
+    confirmAgentSetup: (projectId: string, agentType: string) => Promise<ApiResponse<{
+        success: boolean;
+        project_id: string;
+        agent_type: string;
+    }>>;
+    listProjects: () => Promise<ApiResponse<{
+        projects: Array<{
+            id: string;
+            name: string;
+            description?: string;
+            status: string;
+            git_url?: string;
+            goal?: string;
+            tech_stack?: string[];
+        }>;
+    }>>;
+    createProject: (params: Parameters<ProjectMethods["createProject"]>[0]) => 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: Parameters<ProjectMethods["updateProject"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        project_id: string;
+    }>>;
+    getGitWorkflow: (projectId: string, taskId?: string) => Promise<ApiResponse<{
+        workflow: string;
+        main_branch: string;
+        develop_branch?: string;
+        suggested_branch?: string;
+        base_branch?: string;
+    }>>;
+    updateProjectReadme: (projectId: string, readmeContent: string) => Promise<ApiResponse<{
+        success: boolean;
+        project_id: string;
+    }>>;
+    getProjectSummary: (projectId: string) => Promise<ApiResponse<{
+        project: {
+            id: string;
+            name: string;
+            description?: string;
+            goal?: string;
+            status: string;
+        };
+        stats: {
+            total_tasks: number;
+            completed_tasks: number;
+            in_progress_tasks: number;
+            pending_tasks: number;
+            open_blockers: number;
+            total_decisions: number;
+        };
+    }>>;
+    getBlockers: (projectId: string, params?: Parameters<BlockersMethods["getBlockers"]>[1]) => Promise<ApiResponse<{
+        blockers: Array<{
+            id: string;
+            description: string;
+            status: string;
+            created_at: string;
+            resolved_at?: string;
+            resolution_note?: 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;
+    }>>;
+    getBlockersStats: (projectId: string) => Promise<ApiResponse<{
+        total: number;
+        open: number;
+        resolved: number;
+    }>>;
+    getCostSummary: (projectId: string, params?: Parameters<CostMethods["getCostSummary"]>[1]) => Promise<ApiResponse<{
+        summary: Array<{
+            period: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+            api_calls: number;
+        }>;
+    }>>;
+    getCostAlerts: () => Promise<ApiResponse<{
+        alerts: Array<{
+            id: string;
+            project_id?: string;
+            threshold_amount: number;
+            threshold_period: string;
+            alert_type: string;
+            enabled: boolean;
+        }>;
+    }>>;
+    addCostAlert: (params: Parameters<CostMethods["addCostAlert"]>[0]) => Promise<ApiResponse<{
+        success: boolean;
+        alert_id: string;
+    }>>;
+    updateCostAlert: (alertId: string, updates: Parameters<CostMethods["updateCostAlert"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        alert_id: string;
+    }>>;
+    deleteCostAlert: (alertId: string) => Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getTaskCosts: (projectId: string, limit?: number) => Promise<ApiResponse<{
+        tasks: Array<{
+            task_id: string;
+            task_title: string;
+            total_cost: number;
+            input_tokens: number;
+            output_tokens: number;
+        }>;
+    }>>;
+    getBodyOfWorkCosts: (params: Parameters<CostMethods["getBodyOfWorkCosts"]>[0]) => Promise<ApiResponse<{
+        bodies_of_work: Array<{
+            body_of_work_id: string;
+            title: string;
+            total_cost: number;
+            task_count: number;
+        }>;
+    }>>;
+    getSprintCosts: (params: Parameters<CostMethods["getSprintCosts"]>[0]) => Promise<ApiResponse<{
+        sprints: Array<{
+            sprint_id: string;
+            name: string;
+            total_cost: number;
+            task_count: number;
+        }>;
+    }>>;
+    getTokenUsage: () => Promise<ApiResponse<{
+        session_tokens: {
+            input: number;
+            output: number;
+        };
+        estimated_cost: number;
+    }>>;
+    reportTokenUsage: (sessionId: string, params: Parameters<CostMethods["reportTokenUsage"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        session_id: string;
+        total_input_tokens: number;
+        total_output_tokens: number;
+    }>>;
+    getStaleWorktrees: (projectId: string, params?: Parameters<WorktreesMethods["getStaleWorktrees"]>[1]) => Promise<ApiResponse<{
+        stale_worktrees: Array<{
+            task_id: string;
+            task_title: string;
+            worktree_path: string;
+            worktree_hostname?: string | null;
+            last_heartbeat?: string;
+            session_status?: string;
+        }>;
+        total_count: number;
+        has_more: boolean;
+        cleanup_instructions: string;
+    }>>;
+    clearWorktreePath: (taskId: string) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        message: string;
+    }>>;
+    queryKnowledgeBase: (projectId: string, params?: Parameters<DiscoveryMethods["queryKnowledgeBase"]>[1]) => Promise<ApiResponse<{
+        findings?: Array<{
+            id: string;
+            title: string;
+            category: string;
+            severity: string;
+        }>;
+        qa?: Array<{
+            id: string;
+            question: string;
+            answer?: string;
+        }>;
+        decisions?: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+        completed_tasks?: Array<{
+            id: string;
+            title: string;
+            completed_at: string;
+        }>;
+        blockers?: Array<{
+            id: string;
+            description: string;
+            status: string;
+        }>;
+        progress?: Array<{
+            id: string;
+            note: string;
+            created_at: string;
+        }>;
+    }>>;
+    getHelpTopic: (slug: string) => Promise<ApiResponse<{
+        topic: {
+            slug: string;
+            title: string;
+            content: string;
+        };
+    }>>;
+    getHelpTopics: () => Promise<ApiResponse<{
+        slug: string;
+        title: string;
+        description?: string;
+    }[]>>;
+    getDecisions: (projectId: string, options?: Parameters<DecisionsMethods["getDecisions"]>[1]) => Promise<ApiResponse<{
+        decisions: Array<{
+            id: string;
+            title: string;
+            description: string;
+            rationale?: string;
+            alternatives_considered?: string[];
+            created_at: string;
+        }>;
+        total_count?: number;
+        has_more?: boolean;
+    }>>;
+    getDecision: (decisionId: string) => Promise<ApiResponse<{
+        decision: {
+            id: string;
+            title: string;
+            description: string;
+            rationale?: string;
+            alternatives_considered?: string[];
+            created_at: string;
+        };
+    }>>;
+    logDecision: (projectId: string, params: Parameters<DecisionsMethods["logDecision"]>[1], sessionId?: string) => Promise<ApiResponse<{
+        success: boolean;
+        decision_id: string;
+    }>>;
+    deleteDecision: (decisionId: string) => Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    getDecisionsStats: (projectId: string) => Promise<ApiResponse<{
+        total: number;
+    }>>;
+    getIdeas: (projectId: string, params?: Parameters<IdeasMethods["getIdeas"]>[1]) => Promise<ApiResponse<{
+        ideas: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            doc_url?: string;
+            created_at: string;
+        }>;
+        total_count?: number;
+        has_more?: boolean;
+    }>>;
+    getIdea: (ideaId: string) => Promise<ApiResponse<{
+        idea: {
+            id: string;
+            title: string;
+            description?: string;
+            status: string;
+            doc_url?: string;
+            created_at: string;
+        };
+    }>>;
+    addIdea: (projectId: string, params: Parameters<IdeasMethods["addIdea"]>[1], sessionId?: string) => Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    updateIdea: (ideaId: string, updates: Parameters<IdeasMethods["updateIdea"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        idea_id: string;
+    }>>;
+    deleteIdea: (ideaId: string) => Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+    convertIdeaToTask: (ideaId: string, params?: Parameters<IdeasMethods["convertIdeaToTask"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        task_id?: string;
+        task_title?: string;
+        idea_id?: string;
+        idea_status?: string;
+        message?: string;
+        error?: string;
+    }>>;
+    getTasks: (projectId: string, params?: Parameters<TasksMethods["getTasks"]>[1]) => 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: Parameters<TasksMethods["createTask"]>[1]) => 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;
+        };
+    }>>;
+    getTaskById: (taskId: string, params?: Parameters<TasksMethods["getTaskById"]>[1]) => 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;
+            references?: Array<{
+                url: string;
+                label?: string;
+            }>;
+        };
+        subtasks?: Array<{
+            id: string;
+            title: string;
+            status: string;
+            progress_percentage?: number;
+        }>;
+        milestones?: Array<{
+            id: string;
+            title: string;
+            status: string;
+            order_index: number;
+        }>;
+    }>>;
+    searchTasks: (projectId: string, params: Parameters<TasksMethods["searchTasks"]>[1]) => Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            status: string;
+            priority: number;
+            snippet?: string;
+        }>;
+        total_matches: number;
+        hint?: string;
+    }>>;
+    getTasksByPriority: (projectId: string, params?: Parameters<TasksMethods["getTasksByPriority"]>[1]) => Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            priority: number;
+            status: string;
+            estimated_minutes?: number;
+        }>;
+        total_count: number;
+    }>>;
+    getRecentTasks: (projectId: string, params?: Parameters<TasksMethods["getRecentTasks"]>[1]) => Promise<ApiResponse<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            status: string;
+            priority: number;
+            created_at: string;
+            age?: string;
+        }>;
+        total_count: number;
+    }>>;
+    getTaskStats: (projectId: string) => Promise<ApiResponse<{
+        total: number;
+        by_status: {
+            backlog: number;
+            pending: number;
+            in_progress: number;
+            completed: number;
+            cancelled: number;
+        };
+        by_priority: {
+            1: number;
+            2: number;
+            3: number;
+            4: number;
+            5: number;
+        };
+        awaiting_validation: number;
+        oldest_pending_days: number | null;
+    }>>;
+    updateTask: (taskId: string, updates: Parameters<TasksMethods["updateTask"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        git_workflow?: {
+            workflow: string;
+            base_branch: string;
+            suggested_branch: string;
+            worktree_required: boolean;
+        };
+        worktree_setup?: {
+            message: string;
+            commands: string[];
+            worktree_path: string;
+            branch_name: string;
+            cleanup_command: string;
+        };
+        next_step?: string;
+    }>>;
+    completeTask: (taskId: string, params: Parameters<TasksMethods["completeTask"]>[1]) => 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;
+            worktree_path?: string;
+        };
+        next_action: string;
+        warnings?: string[];
+    }>>;
+    deleteTask: (taskId: string) => Promise<ApiResponse<{
+        success: boolean;
+        deleted_id: string;
+    }>>;
+    releaseTask: (taskId: string, params?: Parameters<TasksMethods["releaseTask"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        message: string;
+        reason?: string;
+        hint: string;
+    }>>;
+    cancelTask: (taskId: string, params?: Parameters<TasksMethods["cancelTask"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        cancelled_reason: string | null;
+        message: string;
+    }>>;
+    addTaskReference: (taskId: string, url: string, label?: string) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+        reference: {
+            url: string;
+            label?: string;
+        };
+    }>>;
+    removeTaskReference: (taskId: string, url: string) => Promise<ApiResponse<{
+        success: boolean;
+        task_id: string;
+    }>>;
+    batchUpdateTasks: (updates: Parameters<TasksMethods["batchUpdateTasks"]>[0]) => Promise<ApiResponse<{
+        success: boolean;
+        updated_count: number;
+        results: Array<{
+            task_id: string;
+            success: boolean;
+            error?: string;
+        }>;
+    }>>;
+    batchCompleteTasks: (completions: Parameters<TasksMethods["batchCompleteTasks"]>[0]) => Promise<ApiResponse<{
+        success: boolean;
+        completed_count: number;
+        results: Array<{
+            task_id: string;
+            success: boolean;
+            error?: string;
+        }>;
+    }>>;
+}
+export declare function getApiClient(): VibescopeApiClient;
+export declare function initApiClient(config: ApiClientConfig): VibescopeApiClient;