mcp-adr-analysis-server/dist/src/utils/memory-entity-manager.d.ts

MCP server for analyzing Architectural Decision Records and project architecture

/**
 * Memory Entity Manager
 *
 * Core manager for the memory-centric architecture that handles storage, retrieval,
 * relationship management, and intelligence operations for memory entities.
 */
import * as fs from 'fs/promises';
import { MemoryEntity, MemoryRelationship, MemoryQuery, MemoryQueryResult, MemorySnapshot, MemoryIntelligence, MemoryPersistenceConfig } from '../types/memory-entities.js';
export declare class MemoryEntityManager {
    private fsOverride?;
    private memoryDir;
    private entitiesFile;
    private relationshipsFile;
    private intelligenceFile;
    private evolutionLogFile;
    private config;
    private logger;
    private isTestMode;
    private entitiesCache;
    private relationshipsCache;
    private intelligence;
    private lastSnapshotTime;
    constructor(config?: Partial<MemoryPersistenceConfig>, testMode?: boolean, fsOverride?: typeof fs | undefined);
    /**
     * Initialize the memory system
     */
    initialize(): Promise<void>;
    /**
     * Create or update a memory entity
     */
    upsertEntity(entity: Partial<MemoryEntity> & Pick<MemoryEntity, 'type' | 'title' | 'description'>): Promise<MemoryEntity>;
    /**
     * Get an entity by ID
     */
    getEntity(id: string): Promise<MemoryEntity | null>;
    /**
     * Delete an entity
     */
    deleteEntity(id: string): Promise<boolean>;
    /**
     * Create or update a relationship between entities
     */
    upsertRelationship(relationship: Partial<MemoryRelationship> & Pick<MemoryRelationship, 'sourceId' | 'targetId' | 'type'>): Promise<MemoryRelationship>;
    /**
     * Query entities with advanced filtering
     */
    queryEntities(query: MemoryQuery): Promise<MemoryQueryResult>;
    /**
     * Find related entities through relationships
     */
    findRelatedEntities(entityId: string, maxDepth?: number, relationshipTypes?: MemoryRelationship['type'][]): Promise<{
        entities: MemoryEntity[];
        relationshipPaths: Array<{
            path: string[];
            relationships: MemoryRelationship[];
            depth: number;
        }>;
    }>;
    /**
     * Get memory intelligence data
     */
    getIntelligence(): Promise<MemoryIntelligence>;
    /**
     * Create a memory snapshot
     */
    createSnapshot(): Promise<MemorySnapshot>;
    private ensureMemoryDirectory;
    private loadFromPersistence;
    private maybePersist;
    private persistToStorage;
    private initializeIntelligence;
    private updateIntelligence;
    private updateRecommendations;
    private updateEntityRelationships;
    private calculateChanges;
    private logEvolutionEvent;
    /**
     * Clear all cached data (useful for testing)
     */
    clearCache(): void;
    /**
     * Force persistence (useful for testing)
     */
    forcePersist(): Promise<void>;
    /**
     * Create cross-tool relationships using the MemoryRelationshipMapper
     */
    createCrossToolRelationships(): Promise<{
        suggestedRelationships: Array<{
            sourceId: string;
            targetId: string;
            type: MemoryRelationship['type'];
            confidence: number;
            reasoning: string;
            evidence: string[];
        }>;
        conflicts: Array<{
            description: string;
            entityIds: string[];
            severity: 'low' | 'medium' | 'high';
            recommendation: string;
        }>;
        autoCreatedCount: number;
    }>;
    /**
     * Infer and suggest new relationships based on existing entity patterns
     */
    inferRelationships(entityTypes?: MemoryEntity['type'][], minConfidence?: number): Promise<{
        suggestedRelationships: Array<{
            sourceId: string;
            targetId: string;
            type: MemoryRelationship['type'];
            confidence: number;
            reasoning: string;
        }>;
    }>;
    /**
     * Validate existing relationships and detect conflicts
     */
    validateRelationships(): Promise<{
        validRelationships: string[];
        invalidRelationships: Array<{
            relationshipId: string;
            reason: string;
            severity: 'low' | 'medium' | 'high';
        }>;
        suggestedActions: Array<{
            action: 'remove' | 'update' | 'investigate';
            relationshipId: string;
            reason: string;
        }>;
    }>;
}
//# sourceMappingURL=memory-entity-manager.d.ts.map