vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
211 lines • 7.02 kB
TypeScript
import { EventEmitter } from 'events';
export interface TaskDecompositionRequest {
taskDescription: string;
projectPath?: string;
domain?: string;
context?: Record<string, unknown>;
}
export interface ResearchRequest {
query: string;
taskContext?: {
taskId?: string;
taskDescription?: string;
projectPath?: string;
domain?: string;
technology?: string[];
};
scope: {
depth: 'shallow' | 'medium' | 'deep';
focus: 'technical' | 'business' | 'market' | 'comprehensive';
timeframe: 'current' | 'recent' | 'historical' | 'future';
};
optimization: {
cacheStrategy: 'none' | 'session' | 'persistent' | 'adaptive';
qualityThreshold: number;
maxQueries: number;
parallelQueries: boolean;
enhanceResults: boolean;
};
integration: {
includeInDecomposition: boolean;
generateSubQueries: boolean;
extractActionItems: boolean;
createKnowledgeBase: boolean;
};
}
export interface EnhancedResearchResult {
content: string;
metadata: {
query: string;
timestamp: number;
model: string;
qualityScore: number;
relevanceScore: number;
completenessScore: number;
sources: string[];
researchTime: number;
};
insights: {
keyFindings: string[];
actionItems: string[];
recommendations: string[];
risks: string[];
opportunities: string[];
technicalConsiderations: string[];
};
integrationData: {
suggestedTasks: Array<{
title: string;
description: string;
priority: 'low' | 'medium' | 'high';
estimatedHours: number;
dependencies: string[];
}>;
knowledgeEntries: Array<{
topic: string;
summary: string;
relevance: number;
tags: string[];
}>;
contextEnrichment: {
additionalQueries: string[];
relatedTopics: string[];
expertiseAreas: string[];
};
};
performance: {
cacheHit: boolean;
processingStages: Record<string, number>;
memoryUsage: number;
apiCalls: number;
enhancementTime?: number;
};
}
export type ResearchProgressCallback = (stage: string, progress: number, message?: string) => void;
export type ResearchCompleteCallback = (result: EnhancedResearchResult) => void;
export interface ResearchPerformanceMetrics {
query: string;
totalTime: number;
qualityScore: number;
cacheHit: boolean;
timestamp: number;
memoryUsage?: number;
apiCalls?: number;
}
export interface ResearchIntegrationConfig {
maxConcurrentRequests: number;
defaultCacheTTL: number;
qualityThresholds: {
minimum: number;
good: number;
excellent: number;
};
performance: {
enableCaching: boolean;
enableParallelQueries: boolean;
maxQueryDepth: number;
timeoutMs: number;
};
integration: {
autoEnhanceDecomposition: boolean;
generateSubQueries: boolean;
extractActionItems: boolean;
createKnowledgeBase: boolean;
};
enhancement: {
temperature: number;
format: 'json' | 'markdown' | 'text' | 'yaml';
timeoutComplexity: 'simple' | 'moderate' | 'complex' | 'critical';
};
}
export declare class ResearchIntegration extends EventEmitter {
private static instance;
private config;
private openRouterConfig?;
private activeRequests;
private researchCache;
private progressSubscriptions;
private completeSubscriptions;
private performanceMetrics;
private cleanupInterval?;
private circuitBreaker;
private constructor();
static getInstance(config?: Partial<ResearchIntegrationConfig>): ResearchIntegration;
performEnhancedResearch(request: ResearchRequest): Promise<EnhancedResearchResult>;
enhanceDecompositionWithResearch(decompositionRequest: TaskDecompositionRequest, researchScope?: Partial<ResearchRequest['scope']>): Promise<{
enhancedRequest: TaskDecompositionRequest;
researchResults: EnhancedResearchResult[];
integrationMetrics: {
researchTime: number;
queriesExecuted: number;
insightsGenerated: number;
tasksEnhanced: number;
};
}>;
generateIntelligentResearchQueries(taskDescription: string, context?: {
projectPath?: string;
domain?: string;
technology?: string[];
existingKnowledge?: string[];
}): Promise<string[]>;
assessResearchQuality(content: string, query: string): {
qualityScore: number;
relevanceScore: number;
completenessScore: number;
issues: string[];
};
subscribeToResearchProgress(requestId: string, callback: ResearchProgressCallback): () => void;
subscribeToResearchComplete(requestId: string, callback: ResearchCompleteCallback): () => void;
getResearchStatistics(): {
activeRequests: number;
cacheSize: number;
totalResearchPerformed: number;
averageResearchTime: number;
cacheHitRate: number;
qualityDistribution: Record<string, number>;
topQueries: Array<{
query: string;
count: number;
avgQuality: number;
}>;
};
clearResearchCache(pattern?: string): number;
updateConfig(newConfig: Partial<ResearchIntegrationConfig>): void;
dispose(): void;
private initializeConfig;
private generateRequestId;
private getCachedResearch;
private cacheResearchResult;
private executeResearchRequest;
private generateResearchQueries;
private integrateResearchIntoDecomposition;
private enhanceTaskDescription;
private buildEnhancementPrompt;
private getResearchSystemPrompt;
private extractInsights;
private generateIntegrationData;
private extractSources;
private estimateMemoryUsage;
private recordPerformanceMetrics;
private notifyProgress;
private notifyCompleteSubscribers;
private startCleanupProcess;
private performCleanup;
private estimateTaskHours;
private extractTopics;
private calculateTopicRelevance;
private generateTopicTags;
private extractRelatedTopics;
private extractExpertiseAreas;
private createDegradedDecompositionRequest;
private inferTechnologiesFromDescription;
private inferComplexityFromDescription;
private extractErrorDetails;
private buildAggregatedEnhancementPrompt;
private getAggregatedResearchSystemPrompt;
private getModelForTask;
private createFallbackSynthesis;
}
export declare const researchIntegration: ResearchIntegration;
export declare function getResearchIntegration(config?: Partial<ResearchIntegrationConfig>): ResearchIntegration;
//# sourceMappingURL=research-integration.d.ts.map