@vibescope/mcp-server 0.3.13 → 0.3.14

package/src/api-client/findings.ts

@@ -1,154 +1,100 @@
 /**
  * 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;
-	}): 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;
-	}>>;
+		search_query?: string;
+		summary_only?: boolean;
+	}): Promise<ApiResponse<{ 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;
-	}>>;
+	getFinding(findingId: string): Promise<ApiResponse<{ finding: Finding }>>;
+
+	getFindingsStats(projectId: string): Promise<ApiResponse<FindingsStats>>;
 
-	addFinding(params: {
-		project_id: string;
+	addFinding(projectId: string, params: {
 		title: string;
 		description?: string;
 		category?: string;
 		severity?: string;
+		file_path?: string;
+		line_number?: number;
 		related_task_id?: string;
-	}): Promise<ApiResponse<{
-		success: boolean;
-		finding_id: string;
-	}>>;
+	}, 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;
-	}): Promise<ApiResponse<{
-		success: boolean;
-		finding_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;
-	}>>;
+	deleteFinding(findingId: string): Promise<ApiResponse<{ success: boolean }>>;
 }
 
-export function createFindingsMethods(request: RequestFn): FindingsMethods {
+export function createFindingsMethods(proxy: ProxyFn): FindingsMethods {
 	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 },
-			});
+			return proxy('get_finding', { finding_id: findingId });
 		},
 
-		async addFinding(params) {
-			return request('/api/mcp/projects/{id}/findings', 'POST', {
-				path: { id: params.project_id },
-				body: params,
-			});
+		async getFindingsStats(projectId) {
+			return proxy('get_findings_stats', { project_id: projectId });
 		},
 
-		async updateFinding(findingId, params) {
-			return request('/api/mcp/findings/{id}', 'PATCH', {
-				path: { id: findingId },
-				body: params,
-			});
+		async addFinding(projectId, params, sessionId) {
+			return proxy('add_finding', {
+				project_id: projectId,
+				...params
+			}, sessionId ? { session_id: sessionId } : undefined);
 		},
 
-		async deleteFinding(findingId) {
-			return request('/api/mcp/findings/{id}', 'DELETE', {
-				path: { id: findingId },
+		async updateFinding(findingId, updates) {
+			return proxy('update_finding', {
+				finding_id: findingId,
+				...updates
 			});
 		},
 
-		async getFindingsStats(projectId) {
-			return request('/api/mcp/projects/{id}/findings/stats', 'GET', {
-				path: { id: projectId },
-			});
-		},
-
-		async queryKnowledgeBase(projectId, params) {
-			return request('/api/mcp/projects/{id}/findings/query', 'POST', {
-				path: { id: projectId },
-				body: params,
-			});
-		},
+		async deleteFinding(findingId) {
+			return proxy('delete_finding', { finding_id: findingId });
+		}
 	};
-}
+}

package/src/api-client/index.ts

@@ -19,6 +19,8 @@ import { createIdeasMethods, type IdeasMethods } from './ideas.js';
 import { createTasksMethods, type TasksMethods } from './tasks.js';
 import { createFindingsMethods, type FindingsMethods } from './findings.js';
 import { createMilestonesMethods, type MilestonesMethods } from './milestones.js';
+import { createValidationMethods, type ValidationMethods } from './validation.js';
+import { createFallbackMethods, type FallbackMethods } from './fallback.js';
 
 // Re-export types
 export type { ApiClientConfig, ApiResponse, RetryConfig, RequestFn, ProxyFn } from './types.js';
@@ -33,6 +35,8 @@ 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';
 
 const DEFAULT_API_URL = 'https://vibescope.dev';
 
@@ -79,8 +83,10 @@ export interface VibescopeApiClientMethods
 		DecisionsMethods,
 		IdeasMethods,
 		TasksMethods,
-		Omit<FindingsMethods, 'queryKnowledgeBase'>,
-		MilestonesMethods {}
+		FindingsMethods,
+		MilestonesMethods,
+		ValidationMethods,
+		FallbackMethods {}
 
 export class VibescopeApiClient implements VibescopeApiClientMethods {
 	private apiKey: string;
@@ -99,6 +105,8 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 	private tasksMethods: TasksMethods;
 	private findingsMethods: FindingsMethods;
 	private milestonesMethods: MilestonesMethods;
+	private validationMethods: ValidationMethods;
+	private fallbackMethods: FallbackMethods;
 
 	constructor(config: ApiClientConfig) {
 		this.apiKey = config.apiKey;
@@ -125,8 +133,10 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 		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);
 	}
 
 	private async request<T>(method: string, path: string, body?: unknown): Promise<ApiResponse<T>> {
@@ -319,27 +329,37 @@ export class VibescopeApiClient implements VibescopeApiClientMethods {
 	// ============================================================================
 	getFindings = (projectId: string, params?: Parameters<FindingsMethods['getFindings']>[1]) => this.findingsMethods.getFindings(projectId, params);
 	getFinding = (findingId: string) => this.findingsMethods.getFinding(findingId);
-	addFinding = (params: Parameters<FindingsMethods['addFinding']>[0]) => this.findingsMethods.addFinding(params);
-	updateFinding = (findingId: string, params: Parameters<FindingsMethods['updateFinding']>[1]) => this.findingsMethods.updateFinding(findingId, params);
-	deleteFinding = (findingId: string) => this.findingsMethods.deleteFinding(findingId);
 	getFindingsStats = (projectId: string) => this.findingsMethods.getFindingsStats(projectId);
-	// queryKnowledgeBase from FindingsMethods removed - duplicates DiscoveryMethods.queryKnowledgeBase (delegated above)
+	addFinding = (projectId: string, params: Parameters<FindingsMethods['addFinding']>[1], sessionId?: string) => this.findingsMethods.addFinding(projectId, params, sessionId);
+	updateFinding = (findingId: string, updates: Parameters<FindingsMethods['updateFinding']>[1]) => this.findingsMethods.updateFinding(findingId, updates);
+	deleteFinding = (findingId: string) => this.findingsMethods.deleteFinding(findingId);
 
 	// ============================================================================
 	// Milestones methods (delegated)
 	// ============================================================================
-	getMilestones = (projectId: string, params?: Parameters<MilestonesMethods['getMilestones']>[1]) => this.milestonesMethods.getMilestones(projectId, params);
-	addMilestone = (params: Parameters<MilestonesMethods['addMilestone']>[0]) => this.milestonesMethods.addMilestone(params);
-	updateMilestone = (milestoneId: string, params: Parameters<MilestonesMethods['updateMilestone']>[1]) => this.milestonesMethods.updateMilestone(milestoneId, params);
-	completeMilestone = (milestoneId: string, params?: Parameters<MilestonesMethods['completeMilestone']>[1]) => this.milestonesMethods.completeMilestone(milestoneId, params);
+	getMilestones = (taskId: string) => this.milestonesMethods.getMilestones(taskId);
+	addMilestone = (taskId: string, params: Parameters<MilestonesMethods['addMilestone']>[1], sessionId?: string) => this.milestonesMethods.addMilestone(taskId, params, sessionId);
+	updateMilestone = (milestoneId: string, updates: Parameters<MilestonesMethods['updateMilestone']>[1]) => this.milestonesMethods.updateMilestone(milestoneId, updates);
+	completeMilestone = (milestoneId: string) => this.milestonesMethods.completeMilestone(milestoneId);
 	deleteMilestone = (milestoneId: string) => this.milestonesMethods.deleteMilestone(milestoneId);
 
+	// ============================================================================
+	// Validation methods (delegated)
+	// ============================================================================
+	getTasksAwaitingValidation = (projectId: string) => this.validationMethods.getTasksAwaitingValidation(projectId);
+	claimValidation = (taskId: string, sessionId?: string) => this.validationMethods.claimValidation(taskId, sessionId);
+	validateTask = (taskId: string, params: Parameters<ValidationMethods['validateTask']>[1], sessionId?: string) => this.validationMethods.validateTask(taskId, params, sessionId);
+
+	// ============================================================================
+	// Fallback activity methods (delegated)
+	// ============================================================================
+	startFallbackActivity = (projectId: string, activity: string, sessionId?: string) => this.fallbackMethods.startFallbackActivity(projectId, activity, sessionId);
+	stopFallbackActivity = (projectId: string, summary?: string, sessionId?: string) => this.fallbackMethods.stopFallbackActivity(projectId, summary, sessionId);
+
 	// ============================================================================
 	// TODO: Additional methods to be migrated from original api-client.ts
 	// The following domains need to be split into separate files:
 	// - requests.ts (getPendingRequests, answerQuestion, etc.)
-	// - validation.ts (getTasksAwaitingValidation, validateTask, etc.)
-	// - fallback.ts (startFallbackActivity, stopFallbackActivity)
 	// - deployment.ts (requestDeployment, startDeployment, etc.)
 	// - organizations.ts (listOrganizations, etc.)
 	// - bodies-of-work.ts (createBodyOfWork, etc.)

package/src/api-client/milestones.ts

@@ -1,103 +1,83 @@
 /**
  * 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<{
-		success: boolean;
-		milestone_id: string;
-	}>>;
+		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;
-	}>>;
+	deleteMilestone(milestoneId: string): Promise<ApiResponse<{ success: boolean }>>;
 }
 
-export function createMilestonesMethods(request: RequestFn): MilestonesMethods {
+export function createMilestonesMethods(proxy: ProxyFn): MilestonesMethods {
 	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 });
+		}
 	};
-}
+}

package/src/api-client/validation.ts

@@ -0,0 +1,60 @@
+/**
+ * Validation API Methods
+ *
+ * Handles task validation workflow for code review and approval.
+ */
+
+import type { ApiResponse, ProxyFn } from './types.js';
+
+export interface TaskAwaitingValidation {
+	id: string;
+	title: string;
+	completed_at?: string;
+	completed_by_session_id?: string;
+}
+
+export interface ValidationMethods {
+	getTasksAwaitingValidation(projectId: string): Promise<ApiResponse<{
+		tasks: TaskAwaitingValidation[];
+	}>>;
+
+	claimValidation(taskId: string, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		task_id: string;
+	}>>;
+
+	validateTask(taskId: string, params: {
+		approved: boolean;
+		validation_notes?: string;
+		skip_pr_check?: boolean;
+		pr_checks_passing?: boolean;
+		create_fix_task?: boolean;
+	}, sessionId?: string): Promise<ApiResponse<{
+		success: boolean;
+		approved: boolean;
+		task_id: string;
+		message?: string;
+		workflow?: string;
+	}>>;
+}
+
+export function createValidationMethods(proxy: ProxyFn): ValidationMethods {
+	return {
+		async getTasksAwaitingValidation(projectId) {
+			return proxy('get_tasks_awaiting_validation', { project_id: projectId });
+		},
+
+		async claimValidation(taskId, sessionId) {
+			return proxy('claim_validation', { task_id: taskId }, sessionId ? {
+				session_id: sessionId
+			} : undefined);
+		},
+
+		async validateTask(taskId, params, sessionId) {
+			return proxy('validate_task', {
+				task_id: taskId,
+				...params
+			}, sessionId ? { session_id: sessionId } : undefined);
+		}
+	};
+}