/**
 * Graph-based memory system for code intelligence
 * Explores different database approaches for agent memory
 */
export interface GraphNode {
    id: string;
    type: 'file' | 'function' | 'class' | 'variable' | 'import' | 'test' | 'commit';
    name: string;
    properties: Record<string, any>;
    timestamp: Date;
}
export interface GraphEdge {
    from: string;
    to: string;
    type: 'calls' | 'imports' | 'extends' | 'implements' | 'tests' | 'modifies' | 'depends_on';
    properties?: Record<string, any>;
    timestamp: Date;
}
export interface MemoryQuery {
    type: 'graph' | 'temporal' | 'semantic';
    query: string;
    timeRange?: {
        start: Date;
        end: Date;
    };
    depth?: number;
}
/**
 * In-memory graph database for code relationships
 * Lightweight alternative to Neo4j for local use
 */
export declare class CodeGraphMemory {
    private nodes;
    private edges;
    private temporalIndex;
    /**
     * Add a node to the graph
     */
    addNode(node: GraphNode): void;
    /**
     * Add an edge between nodes
     */
    addEdge(edge: GraphEdge): void;
    /**
     * Find all nodes connected to a given node
     */
    getConnectedNodes(nodeId: string, edgeType?: string, depth?: number): GraphNode[];
    /**
     * Find nodes modified within a time range
     */
    getNodesInTimeRange(start: Date, end: Date): GraphNode[];
    /**
     * Find dependency chains
     */
    findDependencyChain(fromId: string, toId: string): GraphNode[][];
    /**
     * Detect circular dependencies
     */
    detectCycles(): string[][];
}
/**
 * Document-based memory using embeddings and metadata
 */
export declare class DocumentMemory {
    private documents;
    addDocument(id: string, content: string, metadata: Record<string, any>): void;
    searchByMetadata(query: Record<string, any>): Array<[string, any]>;
}
/**
 * Time-series memory for tracking code evolution
 */
export declare class TimeSeriesMemory {
    private events;
    addEvent(type: string, data: any, tags?: string[]): void;
    queryByTimeRange(start: Date, end: Date, type?: string): any[];
    getEventPatterns(windowSize?: number): Record<string, number>;
}
/**
 * Unified memory interface combining all approaches
 */
export declare class HybridCodeMemory {
    private graph;
    private documents;
    private timeSeries;
    constructor();
    /**
     * Record a code change with full context
     */
    recordCodeChange(change: {
        file: string;
        type: 'create' | 'modify' | 'delete';
        functions?: string[];
        imports?: string[];
        tests?: string[];
    }): void;
    /**
     * Query memory with context awareness
     */
    query(query: MemoryQuery): any;
    /**
     * Get coding patterns and insights
     */
    getInsights(): {
        recentPatterns: Record<string, number>;
        dependencies: string[][];
        hotspots: string[];
    };
    private findHotspots;
}
//# sourceMappingURL=graph-memory.d.ts.map