csvlod-ai-mcp-server/dist/context-intelligence-engine.d.ts

CSVLOD-AI MCP Server v3.0 with Quantum Context Intelligence - Revolutionary Context Intelligence Engine and Multimodal Processor for sovereign AI development

/**
 * CSVLOD-AI Framework v3.0 - Context Intelligence Engine
 * Revolutionary dynamic context system with semantic understanding
 */
export interface ContextNode {
    id: string;
    type: ContextType;
    content: string;
    metadata: NodeMetadata;
    relationships: string[];
    embeddings: number[];
    lastAccessed: Date;
    usageFrequency: number;
    effectivenessScore: number;
}
export interface Relationship {
    source: string;
    target: string;
    type: RelationshipType;
    strength: number;
    bidirectional: boolean;
    contextual: boolean;
    derivedFrom: string[];
}
export interface ContextGraph {
    nodes: Map<string, ContextNode>;
    relationships: Map<string, Relationship[]>;
    semanticIndex: Map<string, string[]>;
    versionHistory: VersionEntry[];
}
export interface ContextPrediction {
    requiredNodes: string[];
    confidence: number;
    reasoning: string;
    alternatives: string[][];
    estimatedLoadTime: number;
}
export interface LoadingStrategy {
    priority1: string[];
    priority2: string[];
    priority3: string[];
    totalLoadTime: number;
    memoryFootprint: number;
}
export declare enum ContextType {
    PRINCIPLE = "principle",
    STANDARD = "standard",
    VISION = "vision",
    LANDSCAPE = "landscape",
    INITIATIVE = "initiative",
    DESIGN = "design",
    PATTERN = "pattern",
    DECISION = "decision"
}
export declare enum RelationshipType {
    DEPENDS_ON = "depends_on",
    IMPLEMENTS = "implements",
    REFERENCES = "references",
    CONFLICTS_WITH = "conflicts_with",
    ENHANCES = "enhances",
    SUPERSEDES = "supersedes",
    DERIVED_FROM = "derived_from"
}
interface NodeMetadata {
    category: string;
    lastUpdated: Date;
    version: string;
    tags: string[];
    autoUpdateEnabled: boolean;
}
interface VersionEntry {
    timestamp: Date;
    version: string;
    changes: string[];
}
/**
 * Context Intelligence Engine - Core implementation
 */
export declare class ContextIntelligenceEngine {
    private graph;
    private projectRoot;
    private v3ConfigPath;
    private cache;
    private performanceMetrics;
    constructor(projectRoot: string);
    /**
     * Initialize the Context Intelligence Engine
     */
    private initializeEngine;
    /**
     * Load context graph from v3.0 structure
     */
    private loadContextGraph;
    /**
     * Migrate v2.x context files to v3.0 graph structure
     */
    private migrateV2Context;
    /**
     * Build semantic index for fast context retrieval
     */
    private buildSemanticIndex;
    /**
     * Query context using dynamic intelligence
     */
    query(request: ContextQuery): Promise<ContextResponse>;
    /**
     * Predict required context for a task
     */
    private predictRequiredContext;
    /**
     * Optimize context loading strategy
     */
    private optimizeContextLoading;
    /**
     * Load context nodes based on strategy
     */
    private loadContextNodes;
    /**
     * Find relevant relationships between nodes
     */
    private findRelevantRelationships;
    /**
     * Calculate confidence score for context response
     */
    private calculateConfidence;
    /**
     * Generate reasoning for context selection
     */
    private generateReasoning;
    /**
     * Generate suggestions for context improvement
     */
    private generateSuggestions;
    /**
     * Update usage metrics for performance monitoring
     */
    private updateUsageMetrics;
    /**
     * Save context graph to persistent storage
     */
    private saveContextGraph;
    /**
     * Extract keywords from text content
     */
    private extractKeywords;
    /**
     * Extract concepts from text content
     */
    private extractConcepts;
    /**
     * Identify domain from query
     */
    private identifyDomain;
    /**
     * Calculate relevance score for a node
     */
    private calculateRelevanceScore;
    /**
     * Get performance metrics
     */
    getPerformanceMetrics(): PerformanceMetrics;
}
interface ContextQuery {
    query: string;
    domain?: string;
    maxResults?: number;
    includeRelated?: boolean;
}
interface ContextResponse {
    nodes: ContextNode[];
    relationships: Relationship[];
    confidence: number;
    reasoning: string;
    suggestions: string[];
    loadTime: number;
}
interface PerformanceMetrics {
    contextLoadTime: number[];
    queryResponseTime: number[];
    cacheHitRatio: number;
    totalQueries: number;
}
export default ContextIntelligenceEngine;
//# sourceMappingURL=context-intelligence-engine.d.ts.map