import { Tool } from '@modelcontextprotocol/sdk/types.js';
import { type CodingContext, type AIInsights, type SemanticInsight, type PatternRecommendation, type CodingApproachPrediction, type DeveloperProfile } from '../types.js';
import { SemanticEngine } from '../../engines/semantic-engine.js';
import { PatternEngine } from '../../engines/pattern-engine.js';
import { SQLiteDatabase } from '../../storage/sqlite-db.js';
import { SemanticVectorDB } from '../../storage/vector-db.js';
export declare class IntelligenceTools {
    private semanticEngine;
    private patternEngine;
    private database;
    private vectorDB?;
    constructor(semanticEngine: SemanticEngine, patternEngine: PatternEngine, database: SQLiteDatabase, vectorDB?: SemanticVectorDB | undefined);
    get tools(): Tool[];
    learnCodebaseIntelligence(args: {
        path: string;
        force?: boolean;
    }): Promise<{
        success: boolean;
        conceptsLearned: number;
        patternsLearned: number;
        featuresLearned?: number;
        insights: string[];
        timeElapsed: number;
        blueprint?: {
            techStack: string[];
            entryPoints: Record<string, string>;
            keyDirectories: Record<string, string>;
            architecture: string;
        };
    }>;
    getSemanticInsights(args: {
        query?: string;
        conceptType?: string;
        limit?: number;
    }): Promise<{
        insights: SemanticInsight[];
        totalAvailable: number;
    }>;
    getPatternRecommendations(args: CodingContext & {
        includeRelatedFiles?: boolean;
    }): Promise<{
        recommendations: PatternRecommendation[];
        reasoning: string;
        relatedFiles?: string[];
    }>;
    predictCodingApproach(args: {
        problemDescription: string;
        context?: Record<string, any>;
        includeFileRouting?: boolean;
    }): Promise<CodingApproachPrediction & {
        fileRouting?: {
            intendedFeature: string;
            targetFiles: string[];
            workType: string;
            suggestedStartPoint: string;
            confidence: number;
            reasoning: string;
        };
    }>;
    getDeveloperProfile(args: {
        includeRecentActivity?: boolean;
        includeWorkContext?: boolean;
    }): Promise<DeveloperProfile>;
    contributeInsights(args: AIInsights & {
        sessionUpdate?: {
            files?: string[];
            feature?: string;
            tasks?: string[];
            decisions?: Record<string, string>;
        };
    }): Promise<{
        success: boolean;
        insightId: string;
        message: string;
        sessionUpdated?: boolean;
    }>;
    private updateWorkSession;
    getProjectBlueprint(args: {
        path?: string;
        includeFeatureMap?: boolean;
    }): Promise<{
        techStack: string[];
        entryPoints: Record<string, string>;
        keyDirectories: Record<string, string>;
        architecture: string;
        featureMap?: Record<string, string[]>;
        learningStatus?: {
            hasIntelligence: boolean;
            isStale: boolean;
            conceptsStored: number;
            patternsStored: number;
            recommendation: string;
            message: string;
        };
    }>;
    /**
     * Get learning/intelligence status for the project
     * Phase 4: Merged from automation-tools get_learning_status
     */
    private getLearningStatus;
    private checkExistingIntelligence;
    private checkExistingIntelligenceInDatabase;
    private storeIntelligence;
    private extractNamingConventions;
    private extractStructuralPreferences;
    private extractTestingApproach;
    private extractExpertiseAreas;
    private extractRecentFocus;
    private analyzeCodebaseRelationships;
    private generateLearningInsights;
    private storeProjectBlueprint;
    private inferArchitecturePattern;
    private inferArchitectureFromBlueprint;
    private buildSemanticIndex;
}
//# sourceMappingURL=intelligence-tools.d.ts.map