@vibescope/mcp-server 0.3.12 → 0.3.14

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

@@ -0,0 +1,33 @@
+/**
+ * Fallback Activity API Methods
+ *
+ * Handles background activities when agents are idle with no pending tasks.
+ */
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface FallbackActivityResult {
+    success: boolean;
+    activity: string;
+    message: string;
+    git_workflow?: {
+        workflow: string;
+        base_branch: string;
+        worktree_recommended: boolean;
+        note: string;
+    };
+    worktree_setup?: {
+        message: string;
+        commands: string[];
+        worktree_path: string;
+        branch_name: string;
+        cleanup_command: string;
+        report_worktree: string;
+    };
+    next_step?: string;
+}
+export interface FallbackMethods {
+    startFallbackActivity(projectId: string, activity: string, sessionId?: string): Promise<ApiResponse<FallbackActivityResult>>;
+    stopFallbackActivity(projectId: string, summary?: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+    }>>;
+}
+export declare function createFallbackMethods(proxy: ProxyFn): FallbackMethods;

package/dist/api-client/fallback.js

@@ -0,0 +1,21 @@
+/**
+ * Fallback Activity API Methods
+ *
+ * Handles background activities when agents are idle with no pending tasks.
+ */
+export function createFallbackMethods(proxy) {
+    return {
+        async startFallbackActivity(projectId, activity, sessionId) {
+            return proxy('start_fallback_activity', {
+                project_id: projectId,
+                activity
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async stopFallbackActivity(projectId, summary, sessionId) {
+            return proxy('stop_fallback_activity', {
+                project_id: projectId,
+                summary
+            }, sessionId ? { session_id: sessionId } : undefined);
+        }
+    };
+}

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

@@ -1,97 +1,69 @@
 /**
  * Findings API Methods
  *
- * Methods for audit findings and knowledge base management:
- * - getFindings: List findings for a project
- * - getFinding: Get a specific finding
- * - addFinding: Create a new finding
- * - updateFinding: Update an existing finding
- * - deleteFinding: Delete a finding
- * - getFindingsStats: Get findings statistics
- * - queryKnowledgeBase: Search findings as knowledge base
+ * Handles security findings, code quality issues, and audit findings.
  */
-import type { ApiResponse, RequestFn } from './types.js';
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface Finding {
+    id: string;
+    title: string;
+    description?: string;
+    category: string;
+    severity: string;
+    status: string;
+    file_path?: string;
+    line_number?: number;
+    resolution_note?: string;
+    created_at: string;
+}
+export interface FindingsStats {
+    total: number;
+    by_status: Record<string, number>;
+    by_severity: Record<string, number>;
+    by_category: Record<string, number>;
+}
 export interface FindingsMethods {
     getFindings(projectId: string, params?: {
         category?: string;
         severity?: string;
         status?: string;
-        summary_only?: boolean;
         limit?: number;
         offset?: number;
+        search_query?: string;
+        summary_only?: boolean;
     }): Promise<ApiResponse<{
-        findings: Array<{
-            id: string;
-            title: string;
-            description?: string;
-            category: string;
-            severity: string;
-            status: string;
-            created_at: string;
-            updated_at?: string;
-            related_task_id?: string;
-        }>;
-        total_count: number;
-        has_more: boolean;
+        findings: Finding[];
+        total_count?: number;
+        has_more?: boolean;
     }>>;
     getFinding(findingId: string): Promise<ApiResponse<{
-        id: string;
-        title: string;
-        description?: string;
-        category: string;
-        severity: string;
-        status: string;
-        created_at: string;
-        updated_at?: string;
-        related_task_id?: string;
+        finding: Finding;
     }>>;
-    addFinding(params: {
-        project_id: string;
+    getFindingsStats(projectId: string): Promise<ApiResponse<FindingsStats>>;
+    addFinding(projectId: string, params: {
         title: string;
         description?: string;
         category?: string;
         severity?: string;
+        file_path?: string;
+        line_number?: number;
         related_task_id?: string;
-    }): Promise<ApiResponse<{
+    }, sessionId?: string): Promise<ApiResponse<{
         success: boolean;
         finding_id: string;
     }>>;
-    updateFinding(findingId: string, params: {
+    updateFinding(findingId: string, updates: {
         title?: string;
         description?: string;
-        category?: string;
         severity?: string;
         status?: string;
-        related_task_id?: string;
+        resolution_note?: string;
     }): Promise<ApiResponse<{
         success: boolean;
         finding_id: string;
     }>>;
     deleteFinding(findingId: string): Promise<ApiResponse<{
         success: boolean;
-        finding_id: string;
-    }>>;
-    getFindingsStats(projectId: string): Promise<ApiResponse<{
-        total: number;
-        by_severity: Record<string, number>;
-        by_category: Record<string, number>;
-        by_status: Record<string, number>;
-    }>>;
-    queryKnowledgeBase(projectId: string, params: {
-        query: string;
-        category?: string;
-        severity?: string;
-        limit?: number;
-    }): Promise<ApiResponse<{
-        findings: Array<{
-            id: string;
-            title: string;
-            description?: string;
-            category: string;
-            severity: string;
-            relevance_score?: number;
-        }>;
-        total_count: number;
     }>>;
 }
-export declare function createFindingsMethods(request: RequestFn): FindingsMethods;
+export declare function createFindingsMethods(proxy: ProxyFn): FindingsMethods;

package/dist/api-client/findings.js

@@ -1,55 +1,36 @@
 /**
  * Findings API Methods
  *
- * Methods for audit findings and knowledge base management:
- * - getFindings: List findings for a project
- * - getFinding: Get a specific finding
- * - addFinding: Create a new finding
- * - updateFinding: Update an existing finding
- * - deleteFinding: Delete a finding
- * - getFindingsStats: Get findings statistics
- * - queryKnowledgeBase: Search findings as knowledge base
+ * Handles security findings, code quality issues, and audit findings.
  */
-export function createFindingsMethods(request) {
+export function createFindingsMethods(proxy) {
     return {
         async getFindings(projectId, params) {
-            return request('/api/mcp/projects/{id}/findings', 'GET', {
-                path: { id: projectId },
-                query: params,
+            return proxy('get_findings', {
+                project_id: projectId,
+                ...params
             });
         },
         async getFinding(findingId) {
-            return request('/api/mcp/findings/{id}', 'GET', {
-                path: { id: findingId },
-            });
-        },
-        async addFinding(params) {
-            return request('/api/mcp/projects/{id}/findings', 'POST', {
-                path: { id: params.project_id },
-                body: params,
-            });
-        },
-        async updateFinding(findingId, params) {
-            return request('/api/mcp/findings/{id}', 'PATCH', {
-                path: { id: findingId },
-                body: params,
-            });
-        },
-        async deleteFinding(findingId) {
-            return request('/api/mcp/findings/{id}', 'DELETE', {
-                path: { id: findingId },
-            });
+            return proxy('get_finding', { finding_id: findingId });
         },
         async getFindingsStats(projectId) {
-            return request('/api/mcp/projects/{id}/findings/stats', 'GET', {
-                path: { id: projectId },
-            });
+            return proxy('get_findings_stats', { project_id: projectId });
         },
-        async queryKnowledgeBase(projectId, params) {
-            return request('/api/mcp/projects/{id}/findings/query', 'POST', {
-                path: { id: projectId },
-                body: params,
+        async addFinding(projectId, params, sessionId) {
+            return proxy('add_finding', {
+                project_id: projectId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
+        },
+        async updateFinding(findingId, updates) {
+            return proxy('update_finding', {
+                finding_id: findingId,
+                ...updates
             });
         },
+        async deleteFinding(findingId) {
+            return proxy('delete_finding', { finding_id: findingId });
+        }
     };
 }

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

@@ -18,6 +18,8 @@ import { type IdeasMethods } from './ideas.js';
 import { type TasksMethods } from './tasks.js';
 import { type FindingsMethods } from './findings.js';
 import { type MilestonesMethods } from './milestones.js';
+import { type ValidationMethods } from './validation.js';
+import { type FallbackMethods } from './fallback.js';
 export type { ApiClientConfig, ApiResponse, RetryConfig, RequestFn, ProxyFn } from './types.js';
 export type { SessionMethods } from './session.js';
 export type { ProjectMethods } from './project.js';
@@ -30,10 +32,12 @@ export type { IdeasMethods } from './ideas.js';
 export type { TasksMethods } from './tasks.js';
 export type { FindingsMethods } from './findings.js';
 export type { MilestonesMethods } from './milestones.js';
+export type { ValidationMethods } from './validation.js';
+export type { FallbackMethods } from './fallback.js';
 /**
  * Combined interface for all API methods
  */
-export interface VibescopeApiClientMethods extends SessionMethods, ProjectMethods, BlockersMethods, CostMethods, WorktreesMethods, DiscoveryMethods, DecisionsMethods, IdeasMethods, TasksMethods, Omit<FindingsMethods, 'queryKnowledgeBase'>, MilestonesMethods {
+export interface VibescopeApiClientMethods extends SessionMethods, ProjectMethods, BlockersMethods, CostMethods, WorktreesMethods, DiscoveryMethods, DecisionsMethods, IdeasMethods, TasksMethods, FindingsMethods, MilestonesMethods, ValidationMethods, FallbackMethods {
 }
 export declare class VibescopeApiClient implements VibescopeApiClientMethods {
     private apiKey;
@@ -50,6 +54,8 @@ export declare class VibescopeApiClient implements VibescopeApiClientMethods {
     private tasksMethods;
     private findingsMethods;
     private milestonesMethods;
+    private validationMethods;
+    private fallbackMethods;
     constructor(config: ApiClientConfig);
     private request;
     /**
@@ -574,11 +580,7 @@ export declare class VibescopeApiClient implements VibescopeApiClientMethods {
             estimated_minutes?: number;
             started_at?: string;
             completed_at?: string;
-            git_branch
-            /**
-             * Combined interface for all API methods
-             */
-            ?: string;
+            git_branch?: string;
             blocking?: boolean;
             references?: Array<{
                 url: string;
@@ -755,78 +757,69 @@ export declare class VibescopeApiClient implements VibescopeApiClientMethods {
         }>;
     }>>;
     getFindings: (projectId: string, params?: Parameters<FindingsMethods["getFindings"]>[1]) => Promise<ApiResponse<{
-        findings: Array<{
-            id: string;
-            title: string;
-            description?: string;
-            category: string;
-            severity: string;
-            status: string;
-            created_at: string;
-            updated_at?: string;
-            related_task_id?: string;
-        }>;
-        total_count: number;
-        has_more: boolean;
+        findings: import("./findings.js").Finding[];
+        total_count?: number;
+        has_more?: boolean;
     }>>;
     getFinding: (findingId: string) => Promise<ApiResponse<{
-        id: string;
-        title: string;
-        description?: string;
-        category: string;
-        severity: string;
-        status: string;
-        created_at: string;
-        updated_at?: string;
-        related_task_id?: string;
+        finding: import("./findings.js").Finding;
     }>>;
-    addFinding: (params: Parameters<FindingsMethods["addFinding"]>[0]) => Promise<ApiResponse<{
+    getFindingsStats: (projectId: string) => Promise<ApiResponse<import("./findings.js").FindingsStats>>;
+    addFinding: (projectId: string, params: Parameters<FindingsMethods["addFinding"]>[1], sessionId?: string) => Promise<ApiResponse<{
         success: boolean;
         finding_id: string;
     }>>;
-    updateFinding: (findingId: string, params: Parameters<FindingsMethods["updateFinding"]>[1]) => Promise<ApiResponse<{
+    updateFinding: (findingId: string, updates: Parameters<FindingsMethods["updateFinding"]>[1]) => Promise<ApiResponse<{
         success: boolean;
         finding_id: string;
     }>>;
     deleteFinding: (findingId: string) => Promise<ApiResponse<{
         success: boolean;
-        finding_id: string;
     }>>;
-    getFindingsStats: (projectId: string) => Promise<ApiResponse<{
-        total: number;
-        by_severity: Record<string, number>;
-        by_category: Record<string, number>;
-        by_status: Record<string, number>;
+    getMilestones: (taskId: string) => Promise<ApiResponse<{
+        milestones: import("./milestones.js").Milestone[];
+        stats: import("./milestones.js").MilestoneStats;
     }>>;
-    getMilestones: (projectId: string, params?: Parameters<MilestonesMethods["getMilestones"]>[1]) => Promise<ApiResponse<{
-        milestones: Array<{
+    addMilestone: (taskId: string, params: Parameters<MilestonesMethods["addMilestone"]>[1], sessionId?: string) => Promise<ApiResponse<{
+        success: boolean;
+        milestone_id: string;
+    }>>;
+    updateMilestone: (milestoneId: string, updates: Parameters<MilestonesMethods["updateMilestone"]>[1]) => Promise<ApiResponse<{
+        success: boolean;
+        milestone: {
             id: string;
             title: string;
-            description?: string;
-            due_date?: string;
             status: string;
-            created_at: string;
-            completed_at?: string;
-        }>;
-        total_count: number;
-        has_more: boolean;
+        };
     }>>;
-    addMilestone: (params: Parameters<MilestonesMethods["addMilestone"]>[0]) => Promise<ApiResponse<{
+    completeMilestone: (milestoneId: string) => Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
+        milestone: {
+            id: string;
+            title: string;
+            status: string;
+        };
     }>>;
-    updateMilestone: (milestoneId: string, params: Parameters<MilestonesMethods["updateMilestone"]>[1]) => Promise<ApiResponse<{
+    deleteMilestone: (milestoneId: string) => Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
     }>>;
-    completeMilestone: (milestoneId: string, params?: Parameters<MilestonesMethods["completeMilestone"]>[1]) => Promise<ApiResponse<{
+    getTasksAwaitingValidation: (projectId: string) => Promise<ApiResponse<{
+        tasks: import("./validation.js").TaskAwaitingValidation[];
+    }>>;
+    claimValidation: (taskId: string, sessionId?: string) => Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
-        completed_at: string;
+        task_id: string;
     }>>;
-    deleteMilestone: (milestoneId: string) => Promise<ApiResponse<{
+    validateTask: (taskId: string, params: Parameters<ValidationMethods["validateTask"]>[1], sessionId?: string) => Promise<ApiResponse<{
+        success: boolean;
+        approved: boolean;
+        task_id: string;
+        message?: string;
+        workflow?: string;
+    }>>;
+    startFallbackActivity: (projectId: string, activity: string, sessionId?: string) => Promise<ApiResponse<import("./fallback.js").FallbackActivityResult>>;
+    stopFallbackActivity: (projectId: string, summary?: string, sessionId?: string) => Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
     }>>;
 }
 export declare function getApiClient(): VibescopeApiClient;

package/dist/api-client/index.js

@@ -17,6 +17,8 @@ import { createIdeasMethods } from './ideas.js';
 import { createTasksMethods } from './tasks.js';
 import { createFindingsMethods } from './findings.js';
 import { createMilestonesMethods } from './milestones.js';
+import { createValidationMethods } from './validation.js';
+import { createFallbackMethods } from './fallback.js';
 const DEFAULT_API_URL = 'https://vibescope.dev';
 // Retry configuration defaults
 const DEFAULT_RETRY_STATUS_CODES = [429, 503, 504];
@@ -56,6 +58,8 @@ export class VibescopeApiClient {
     tasksMethods;
     findingsMethods;
     milestonesMethods;
+    validationMethods;
+    fallbackMethods;
     constructor(config) {
         this.apiKey = config.apiKey;
         this.baseUrl = config.baseUrl || process.env.VIBESCOPE_API_URL || DEFAULT_API_URL;
@@ -79,8 +83,10 @@ export class VibescopeApiClient {
         this.decisionsMethods = createDecisionsMethods(proxy);
         this.ideasMethods = createIdeasMethods(proxy);
         this.tasksMethods = createTasksMethods(request, proxy);
-        this.findingsMethods = createFindingsMethods(request);
-        this.milestonesMethods = createMilestonesMethods(request);
+        this.findingsMethods = createFindingsMethods(proxy);
+        this.milestonesMethods = createMilestonesMethods(proxy);
+        this.validationMethods = createValidationMethods(proxy);
+        this.fallbackMethods = createFallbackMethods(proxy);
     }
     async request(method, path, body) {
         const url = `${this.baseUrl}${path}`;
@@ -253,19 +259,29 @@ export class VibescopeApiClient {
     // ============================================================================
     getFindings = (projectId, params) => this.findingsMethods.getFindings(projectId, params);
     getFinding = (findingId) => this.findingsMethods.getFinding(findingId);
-    addFinding = (params) => this.findingsMethods.addFinding(params);
-    updateFinding = (findingId, params) => this.findingsMethods.updateFinding(findingId, params);
-    deleteFinding = (findingId) => this.findingsMethods.deleteFinding(findingId);
     getFindingsStats = (projectId) => this.findingsMethods.getFindingsStats(projectId);
-    // queryKnowledgeBase from FindingsMethods removed - duplicates DiscoveryMethods.queryKnowledgeBase (delegated above)
+    addFinding = (projectId, params, sessionId) => this.findingsMethods.addFinding(projectId, params, sessionId);
+    updateFinding = (findingId, updates) => this.findingsMethods.updateFinding(findingId, updates);
+    deleteFinding = (findingId) => this.findingsMethods.deleteFinding(findingId);
     // ============================================================================
     // Milestones methods (delegated)
     // ============================================================================
-    getMilestones = (projectId, params) => this.milestonesMethods.getMilestones(projectId, params);
-    addMilestone = (params) => this.milestonesMethods.addMilestone(params);
-    updateMilestone = (milestoneId, params) => this.milestonesMethods.updateMilestone(milestoneId, params);
-    completeMilestone = (milestoneId, params) => this.milestonesMethods.completeMilestone(milestoneId, params);
+    getMilestones = (taskId) => this.milestonesMethods.getMilestones(taskId);
+    addMilestone = (taskId, params, sessionId) => this.milestonesMethods.addMilestone(taskId, params, sessionId);
+    updateMilestone = (milestoneId, updates) => this.milestonesMethods.updateMilestone(milestoneId, updates);
+    completeMilestone = (milestoneId) => this.milestonesMethods.completeMilestone(milestoneId);
     deleteMilestone = (milestoneId) => this.milestonesMethods.deleteMilestone(milestoneId);
+    // ============================================================================
+    // Validation methods (delegated)
+    // ============================================================================
+    getTasksAwaitingValidation = (projectId) => this.validationMethods.getTasksAwaitingValidation(projectId);
+    claimValidation = (taskId, sessionId) => this.validationMethods.claimValidation(taskId, sessionId);
+    validateTask = (taskId, params, sessionId) => this.validationMethods.validateTask(taskId, params, sessionId);
+    // ============================================================================
+    // Fallback activity methods (delegated)
+    // ============================================================================
+    startFallbackActivity = (projectId, activity, sessionId) => this.fallbackMethods.startFallbackActivity(projectId, activity, sessionId);
+    stopFallbackActivity = (projectId, summary, sessionId) => this.fallbackMethods.stopFallbackActivity(projectId, summary, sessionId);
 }
 // Singleton instance
 let apiClient = null;

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

@@ -1,60 +1,59 @@
 /**
  * Milestones API Methods
  *
- * Methods for milestone management:
- * - getMilestones: List milestones for a project
- * - addMilestone: Create a new milestone
- * - updateMilestone: Update an existing milestone
- * - completeMilestone: Mark milestone as completed
- * - deleteMilestone: Delete a milestone
+ * Handles task milestones for tracking granular progress within tasks.
  */
-import type { ApiResponse, RequestFn } from './types.js';
+import type { ApiResponse, ProxyFn } from './types.js';
+export interface Milestone {
+    id: string;
+    title: string;
+    description?: string;
+    status: string;
+    order_index: number;
+    created_at: string;
+    completed_at?: string;
+}
+export interface MilestoneStats {
+    total: number;
+    completed: number;
+    progress_percentage: number;
+}
 export interface MilestonesMethods {
-    getMilestones(projectId: string, params?: {
-        status?: 'pending' | 'completed';
-        limit?: number;
-        offset?: number;
-    }): Promise<ApiResponse<{
-        milestones: Array<{
-            id: string;
-            title: string;
-            description?: string;
-            due_date?: string;
-            status: string;
-            created_at: string;
-            completed_at?: string;
-        }>;
-        total_count: number;
-        has_more: boolean;
+    getMilestones(taskId: string): Promise<ApiResponse<{
+        milestones: Milestone[];
+        stats: MilestoneStats;
     }>>;
-    addMilestone(params: {
-        project_id: string;
+    addMilestone(taskId: string, params: {
         title: string;
         description?: string;
-        due_date?: string;
-    }): Promise<ApiResponse<{
+        order_index?: number;
+    }, sessionId?: string): Promise<ApiResponse<{
         success: boolean;
         milestone_id: string;
     }>>;
-    updateMilestone(milestoneId: string, params: {
+    updateMilestone(milestoneId: string, updates: {
         title?: string;
         description?: string;
-        due_date?: string;
         status?: string;
+        order_index?: number;
     }): Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
+        milestone: {
+            id: string;
+            title: string;
+            status: string;
+        };
     }>>;
-    completeMilestone(milestoneId: string, params?: {
-        completion_note?: string;
-    }): Promise<ApiResponse<{
+    completeMilestone(milestoneId: string): Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
-        completed_at: string;
+        milestone: {
+            id: string;
+            title: string;
+            status: string;
+        };
     }>>;
     deleteMilestone(milestoneId: string): Promise<ApiResponse<{
         success: boolean;
-        milestone_id: string;
     }>>;
 }
-export declare function createMilestonesMethods(request: RequestFn): MilestonesMethods;
+export declare function createMilestonesMethods(proxy: ProxyFn): MilestonesMethods;

package/dist/api-client/milestones.js

@@ -1,43 +1,30 @@
 /**
  * Milestones API Methods
  *
- * Methods for milestone management:
- * - getMilestones: List milestones for a project
- * - addMilestone: Create a new milestone
- * - updateMilestone: Update an existing milestone
- * - completeMilestone: Mark milestone as completed
- * - deleteMilestone: Delete a milestone
+ * Handles task milestones for tracking granular progress within tasks.
  */
-export function createMilestonesMethods(request) {
+export function createMilestonesMethods(proxy) {
     return {
-        async getMilestones(projectId, params) {
-            return request('/api/mcp/projects/{id}/milestones', 'GET', {
-                path: { id: projectId },
-                query: params,
-            });
+        async getMilestones(taskId) {
+            return proxy('get_milestones', { task_id: taskId });
         },
-        async addMilestone(params) {
-            return request('/api/mcp/projects/{id}/milestones', 'POST', {
-                path: { id: params.project_id },
-                body: params,
-            });
+        async addMilestone(taskId, params, sessionId) {
+            return proxy('add_milestone', {
+                task_id: taskId,
+                ...params
+            }, sessionId ? { session_id: sessionId } : undefined);
         },
-        async updateMilestone(milestoneId, params) {
-            return request('/api/mcp/milestones/{id}', 'PATCH', {
-                path: { id: milestoneId },
-                body: params,
+        async updateMilestone(milestoneId, updates) {
+            return proxy('update_milestone', {
+                milestone_id: milestoneId,
+                ...updates
             });
         },
-        async completeMilestone(milestoneId, params) {
-            return request('/api/mcp/milestones/{id}/complete', 'POST', {
-                path: { id: milestoneId },
-                body: params,
-            });
+        async completeMilestone(milestoneId) {
+            return proxy('complete_milestone', { milestone_id: milestoneId });
         },
         async deleteMilestone(milestoneId) {
-            return request('/api/mcp/milestones/{id}', 'DELETE', {
-                path: { id: milestoneId },
-            });
-        },
+            return proxy('delete_milestone', { milestone_id: milestoneId });
+        }
     };
 }