@aaswe/codebase-ai/dist/services/layer2/in-memory-rdf/InMemoryRDFStore.d.ts

AI-Assisted Software Engineering (AASWE) - Rich codebase context for IDE LLMs

/**
 * In-Memory RDF Store
 *
 * High-performance in-memory RDF storage optimized for LLM queries and MCP context retrieval.
 * Features multiple indexing strategies, semantic search, and intelligent caching.
 */
import { EventEmitter } from 'events';
import { InMemoryRDFStoreInterface, InMemoryRDFConfig, RDFTriple, RDFQueryContext, RDFQueryResult, IndexType, RDFIndex, LLMContext, LLMContextRequest, LLMContextResponse, MCPResource, MCPContextRequest, MCPContextResponse, SemanticSearchResult, RDFStoreMetrics } from './types';
export declare class InMemoryRDFStore extends EventEmitter implements InMemoryRDFStoreInterface {
    private config;
    private triples;
    private indexes;
    private queryCache;
    private mcpResources;
    private llmContextCache;
    private persistenceTimer;
    private optimizationTimer;
    private metrics;
    constructor(config: InMemoryRDFConfig);
    /**
     * Initialize the RDF store
     */
    initialize(): Promise<void>;
    /**
     * Add a single triple to the store
     */
    addTriple(triple: RDFTriple): Promise<boolean>;
    /**
     * Add multiple triples to the store
     */
    addTriples(triples: RDFTriple[]): Promise<number>;
    /**
     * Remove triples matching the pattern
     */
    removeTriple(subject: string, predicate?: string, object?: any): Promise<number>;
    /**
     * Check if a specific triple exists
     */
    hasTriple(subject: string, predicate: string, object: any): Promise<boolean>;
    /**
     * Execute a query against the RDF store
     */
    query<T = any>(query: string, context?: RDFQueryContext): Promise<RDFQueryResult<T>>;
    /**
     * Find triples matching a pattern
     */
    findTriples(pattern: Partial<RDFTriple>, limit?: number): Promise<RDFTriple[]>;
    /**
     * Get all subjects matching the pattern
     */
    getSubjects(predicate?: string, object?: any): Promise<string[]>;
    /**
     * Get all predicates matching the pattern
     */
    getPredicates(subject?: string, object?: any): Promise<string[]>;
    /**
     * Get all objects matching the pattern
     */
    getObjects(subject?: string, predicate?: string): Promise<any[]>;
    /**
     * Get LLM-optimized context for a query
     */
    getLLMContext(request: LLMContextRequest): Promise<LLMContextResponse>;
    /**
     * Build context for a specific query
     */
    buildContextForQuery(query: string, maxTokens?: number): Promise<LLMContext[]>;
    /**
     * Rank contexts by relevance to query
     */
    rankContextByRelevance(contexts: LLMContext[], query: string): Promise<LLMContext[]>;
    /**
     * Get MCP resources
     */
    getMCPResources(request: MCPContextRequest): Promise<MCPContextResponse>;
    /**
     * Register an MCP resource
     */
    registerMCPResource(resource: MCPResource): Promise<boolean>;
    /**
     * Update an MCP resource
     */
    updateMCPResource(uri: string, resource: Partial<MCPResource>): Promise<boolean>;
    /**
     * Perform semantic search
     */
    semanticSearch(query: string, limit?: number): Promise<SemanticSearchResult[]>;
    /**
     * Find similar triples
     */
    findSimilarTriples(triple: RDFTriple, threshold?: number): Promise<SemanticSearchResult[]>;
    /**
     * Build a specific index
     */
    buildIndex(type: IndexType): Promise<void>;
    /**
     * Rebuild all indexes
     */
    rebuildAllIndexes(): Promise<void>;
    /**
     * Get index statistics
     */
    getIndexStats(): Promise<Record<IndexType, RDFIndex>>;
    /**
     * Get comprehensive metrics
     */
    getMetrics(): Promise<RDFStoreMetrics>;
    /**
     * Clear all caches
     */
    clearCache(): Promise<void>;
    /**
     * Optimize the store
     */
    optimize(): Promise<void>;
    /**
     * Shutdown the store
     */
    shutdown(): Promise<void>;
    private initializeMetrics;
    private initializeIndexes;
    private generateTripleId;
    private generateQueryCacheKey;
    private generateLLMContextCacheKey;
    private updateIndexesForTriple;
    private generateIndexKeys;
    private matchesPattern;
    private executeQuery;
    private executeSparqlSelect;
    private executeSparqlConstruct;
    private executeSparqlAsk;
    private executePatternQuery;
    private matchesSparqlPattern;
    private buildLLMContexts;
    private formatTripleForLLM;
    private formatEntityForLLM;
    private formatPredicateForLLM;
    private inferContextType;
    private estimateTokenCount;
    private applyTokenLimits;
    private calculateTextSimilarity;
    private extractSemanticTerms;
    private generateQueryEmbedding;
    private generateTripleEmbedding;
    private calculateMultiDimensionalSimilarity;
    private calculateCompositeSimilarity;
    private applySemanticBoosting;
    private calculateDynamicThreshold;
    private generateRelevanceExplanation;
    private extractSemanticContext;
    private hashString;
    private cosineSimilarity;
    private calculateSemanticSimilarity;
    private calculateStructuralSimilarity;
    private calculateDomainBoosts;
    private calculateRelationshipBoost;
    private calculateTemporalBoost;
    private calculateTypeBoost;
    private isCacheValid;
    private shouldCacheQuery;
    private calculateCacheHitRate;
    private calculateResultSize;
    private cleanupQueryCache;
    private cleanupLLMContextCache;
    private shouldRebuildIndexes;
    private updateMemoryUsage;
    private updateQueryMetrics;
    private invalidateRelatedCaches;
    private loadFromPersistence;
    private saveToPersistence;
    private setupPersistence;
    private setupOptimization;
}
export default InMemoryRDFStore;
//# sourceMappingURL=InMemoryRDFStore.d.ts.map