bugger-mcp/dist/context-collection-engine.d.ts

MCP Server for managing bugs, feature requests, and improvements

import { ParsedStackTrace } from './stack-trace-parser.js';
export type TaskType = 'bug' | 'feature' | 'improvement';
export interface CodeContext {
    id: string;
    taskId: string;
    taskType: TaskType;
    contextType: 'snippet' | 'file_reference' | 'dependency' | 'pattern';
    source: 'ai_collected' | 'manual';
    filePath: string;
    startLine?: number;
    endLine?: number;
    content?: string;
    description: string;
    relevanceScore: number;
    keywords: string[];
    dateCollected: string;
    dateLastChecked?: string;
    isStale?: boolean;
}
export interface CodeSection {
    filePath: string;
    startLine: number;
    endLine: number;
    content: string;
    relevanceScore: number;
    contextType: 'function' | 'class' | 'import' | 'usage' | 'comment';
    relatedEntities: string[];
}
export interface ContextCollectionConfig {
    maxContextsPerTask: number;
    relevanceThreshold: number;
    maxFileSize: number;
    excludePatterns: string[];
    includeExtensions: string[];
    cacheExpiryHours: number;
    enableStalenessTracking: boolean;
    enablePatternMatching: boolean;
    enableDependencyAnalysis: boolean;
    maxTokensPerTask: number;
    maxTokensPerContext: number;
    enableIntelligentSummarization: boolean;
    enableContentDeduplication: boolean;
    compressionThreshold: number;
    taskTypeTokenLimits: {
        bug: number;
        feature: number;
        improvement: number;
    };
    contextScoringWeights: {
        keywordMatch: number;
        entityMatch: number;
        intentMatch: number;
        patternSimilarity: number;
        dependencyStrength: number;
        fileProximity: number;
    };
}
export interface ContextCollectionResult {
    contexts: CodeContext[];
    stackTraces?: ParsedStackTrace[];
    summary: {
        totalContexts: number;
        highRelevanceContexts: number;
        mediumRelevanceContexts: number;
        lowRelevanceContexts: number;
        averageRelevanceScore: number;
        processingTimeMs: number;
        filesAnalyzed: number;
        patternsFound: number;
        dependenciesAnalyzed: number;
        stackTracesFound: number;
    };
    recommendations: string[];
    potentialIssues: string[];
}
export interface TaskAnalysisInput {
    taskId: string;
    taskType: TaskType;
    title: string;
    description: string;
    currentState?: string;
    desiredState?: string;
    expectedBehavior?: string;
    actualBehavior?: string;
    filesLikelyInvolved?: string[];
    keywords?: string[];
    entities?: string[];
}
/**
 * Main context collection engine that orchestrates all analysis components
 */
export declare class ContextCollectionEngine {
    private codeAnalyzer;
    private dependencyAnalyzer;
    private config;
    private contextCache;
    constructor(rootPath?: string, config?: Partial<ContextCollectionConfig>);
    /**
     * Collect contexts for a task using all available analysis methods
     */
    collectContexts(input: TaskAnalysisInput): Promise<ContextCollectionResult>;
    /**
     * Get cached contexts for a task
     */
    getCachedContexts(taskId: string): CodeContext[] | null;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<ContextCollectionConfig>): void;
    /**
     * Clear all caches
     */
    clearCaches(): void;
    /**
     * Parse stack traces from task description text
     */
    private parseStackTraces;
    /**
     * Extract stack trace contexts for code collection
     */
    private extractStackTraceContexts;
    /**
     * Calculate relevance score for stack trace contexts
     */
    private calculateStackTraceRelevance;
    /**
     * Estimate token count for text content
     */
    private estimateTokenCount;
    /**
     * Intelligently summarize content to reduce token usage
     */
    private summarizeContent;
    /**
     * Deduplicate similar contexts based on content similarity
     */
    private deduplicateContexts;
    /**
     * Create a hash of content for deduplication
     */
    private createContentHash;
    /**
     * Apply token-aware filtering to contexts
     */
    private applyTokenFiltering;
    private analyzeTaskText;
    /**
     * Simple keyword extraction (basic fallback when AI analysis isn't available)
     */
    private extractSimpleKeywords;
    /**
     * Simple entity extraction (basic fallback when AI analysis isn't available)
     */
    private extractSimpleEntities;
    /**
     * Check if a word is a common English word
     */
    private isCommonWord;
    private findRelevantPatterns;
    private analyzeDependencies;
    private extractCodeSections;
    private readFileSection;
    private extractRelevantSectionsFromFile;
    private groupRelevantLines;
    private extractImportSections;
    private scoreAndRankContexts;
    private calculateRelevanceScore;
    private calculateIntentMatchScore;
    private filterContexts;
    private convertToCodeContexts;
    private mapContextType;
    private generateContextDescription;
    private generateSummary;
    private generateRecommendations;
    private identifyPotentialIssues;
    private cacheResults;
    private mergeWithDefaultConfig;
}
//# sourceMappingURL=context-collection-engine.d.ts.map