arela/dist/memory/hexi-memory.d.ts

AI-powered CTO with multi-agent orchestration, code summarization, visual testing (web + mobile) for blazing fast development.

import { SessionMemory } from "./session.js";
import { ProjectMemory } from "./project.js";
import { UserMemory } from "./user.js";
import { VectorMemory } from "./vector.js";
import { GraphMemory } from "./graph.js";
import { GovernanceMemory } from "./governance.js";
export declare enum MemoryLayer {
    SESSION = "session",
    PROJECT = "project",
    USER = "user",
    VECTOR = "vector",
    GRAPH = "graph",
    GOVERNANCE = "governance"
}
export interface QueryOptions {
    layers?: MemoryLayer[];
    limit?: number;
    includeContext?: boolean;
}
export interface QueryResult {
    query: string;
    results: any[];
    layers: MemoryLayer[];
    totalResults: number;
    executionTime: number;
}
export interface MultiLayerResult {
    session?: any;
    project?: any;
    user?: any;
    vector?: any[];
    graph?: any;
    governance?: any[];
}
export interface HexiMemoryStats {
    session: any;
    project: any;
    user: any;
    vector: any;
    graph: any;
    governance: any;
    totalMemoryUsage: number;
}
/**
 * HexiMemory - Unified orchestrator for all 6 memory layers
 *
 * Provides a single API to query across:
 * - Session (short-term, current task)
 * - Project (medium-term, project-specific)
 * - User (long-term, cross-project)
 * - Vector (semantic search)
 * - Graph (structural dependencies)
 * - Governance (audit trail)
 */
export declare class HexiMemory {
    private session;
    private project;
    private user;
    private vector;
    private graph;
    private governance;
    private projectPath;
    /**
     * Initialize all 6 memory layers
     */
    init(projectPath: string): Promise<void>;
    /**
     * Query all 6 layers in parallel
     */
    queryAll(query: string): Promise<MultiLayerResult>;
    /**
     * Query specific layers only
     */
    queryLayers(query: string, layers: MemoryLayer[]): Promise<MultiLayerResult>;
    /**
     * Query session memory (current task, open files, recent messages)
     */
    querySession(query: string): Promise<any>;
    /**
     * Query project memory (architecture, decisions, patterns)
     */
    queryProject(query: string): Promise<any>;
    /**
     * Query user memory (preferences, expertise, patterns)
     */
    queryUser(query: string): Promise<any>;
    /**
     * Query vector memory (semantic search)
     */
    queryVector(query: string, limit?: number): Promise<any[]>;
    /**
     * Query graph memory (structural dependencies)
     */
    queryGraph(query: string): Promise<any>;
    /**
     * Query governance memory (audit trail, decisions, changes)
     */
    queryGovernance(query: string, limit?: number): Promise<any[]>;
    /**
     * Get aggregated stats from all layers
     */
    getStats(): Promise<HexiMemoryStats>;
    /**
     * Get individual layer instances (for advanced usage)
     */
    getSession(): SessionMemory;
    getProject(): ProjectMemory;
    getUser(): UserMemory;
    getVector(): VectorMemory;
    getGraph(): GraphMemory;
    getGovernance(): GovernanceMemory;
}
//# sourceMappingURL=hexi-memory.d.ts.map