/**
 * AgentDB Backend - Integration with agentdb@2.0.0-alpha.3.4
 *
 * Provides IMemoryBackend implementation using AgentDB with:
 * - HNSW vector search (150x-12,500x faster than brute-force)
 * - Native or WASM backend support with graceful fallback
 * - Optional dependency handling (works without hnswlib-node)
 * - Seamless integration with HybridBackend
 *
 * @module v3/memory/agentdb-backend
 */
import { EventEmitter } from 'node:events';
// ===== AgentDB Optional Import =====
let AgentDB;
let HNSWIndex;
let isHnswlibAvailable;
// Dynamically import agentdb (handled at runtime)
let agentdbImportPromise;
function ensureAgentDBImport() {
    if (!agentdbImportPromise) {
        agentdbImportPromise = (async () => {
            try {
                const agentdbModule = await import('agentdb');
                AgentDB = agentdbModule.AgentDB || agentdbModule.default;
                HNSWIndex = agentdbModule.HNSWIndex;
                isHnswlibAvailable = agentdbModule.isHnswlibAvailable;
            }
            catch (error) {
                // AgentDB not available - will use fallback
            }
        })();
    }
    return agentdbImportPromise;
}
/**
 * Default configuration
 */
const DEFAULT_CONFIG = {
    namespace: 'default',
    forceWasm: false,
    vectorBackend: 'auto',
    vectorDimension: 1536,
    hnswM: 16,
    hnswEfConstruction: 200,
    hnswEfSearch: 100,
    cacheEnabled: true,
    maxEntries: 1000000,
};
// ===== AgentDB Backend Implementation =====
/**
 * AgentDB Backend
 *
 * Integrates AgentDB for vector search with the V3 memory system.
 * Provides 150x-12,500x faster search compared to brute-force approaches.
 *
 * Features:
 * - HNSW indexing for fast approximate nearest neighbor search
 * - Automatic fallback: native hnswlib → ruvector → WASM
 * - Graceful handling of optional native dependencies
 * - Semantic search with filtering
 * - Compatible with HybridBackend for combined SQLite+AgentDB queries
 */
export class AgentDBBackend extends EventEmitter {
    config;
    agentdb;
    initialized = false;
    available = false;
    // In-memory storage for compatibility
    entries = new Map();
    namespaceIndex = new Map();
    keyIndex = new Map();
    // O(1) reverse lookup for numeric ID -> string ID (fixes O(n) linear scan)
    numericToStringIdMap = new Map();
    // Performance tracking
    stats = {
        queryCount: 0,
        totalQueryTime: 0,
        searchCount: 0,
        totalSearchTime: 0,
    };
    constructor(config = {}) {
        super();
        this.config = { ...DEFAULT_CONFIG, ...config };
        this.available = false; // Will be set during initialization
    }
    /**
     * Initialize AgentDB
     */
    async initialize() {
        if (this.initialized)
            return;
        // Try to import AgentDB
        await ensureAgentDBImport();
        this.available = AgentDB !== undefined;
        if (!this.available) {
            console.warn('AgentDB not available, using fallback in-memory storage');
            this.initialized = true;
            return;
        }
        try {
            // Initialize AgentDB with config
            this.agentdb = new AgentDB({
                dbPath: this.config.dbPath || ':memory:',
                namespace: this.config.namespace,
                forceWasm: this.config.forceWasm,
                vectorBackend: this.config.vectorBackend,
                vectorDimension: this.config.vectorDimension,
            });
            // Suppress agentdb's noisy console.log during init
            // (EmbeddingService, AgentDB core emit info-level logs we don't need)
            const origLog = console.log;
            console.log = (...args) => {
                const msg = String(args[0] ?? '');
                if (msg.includes('Transformers.js loaded') ||
                    msg.includes('Using better-sqlite3') ||
                    msg.includes('better-sqlite3 unavailable') ||
                    msg.includes('[AgentDB]'))
                    return;
                origLog.apply(console, args);
            };
            try {
                await this.agentdb.initialize();
            }
            finally {
                console.log = origLog;
            }
            // Create memory_entries table if it doesn't exist
            await this.createSchema();
            this.initialized = true;
            this.emit('initialized', {
                backend: this.agentdb.vectorBackendName,
                isWasm: this.agentdb.isWasm,
            });
        }
        catch (error) {
            console.error('Failed to initialize AgentDB:', error);
            this.available = false;
            this.initialized = true;
            this.emit('initialization:failed', { error });
        }
    }
    /**
     * Shutdown AgentDB
     */
    async shutdown() {
        if (!this.initialized)
            return;
        if (this.agentdb) {
            await this.agentdb.close();
        }
        this.initialized = false;
        this.emit('shutdown');
    }
    /**
     * Store a memory entry
     */
    async store(entry) {
        // Generate embedding if needed
        if (entry.content && !entry.embedding && this.config.embeddingGenerator) {
            entry.embedding = await this.config.embeddingGenerator(entry.content);
        }
        // Store in-memory for quick access
        this.entries.set(entry.id, entry);
        // Register ID mapping for O(1) reverse lookup
        this.registerIdMapping(entry.id);
        // Update indexes
        this.updateIndexes(entry);
        // Store in AgentDB if available
        if (this.agentdb) {
            await this.storeInAgentDB(entry);
        }
        this.emit('entry:stored', { id: entry.id });
    }
    /**
     * Get entry by ID
     */
    async get(id) {
        // Check in-memory first
        const cached = this.entries.get(id);
        if (cached)
            return cached;
        // Query AgentDB if available
        if (this.agentdb) {
            return this.getFromAgentDB(id);
        }
        return null;
    }
    /**
     * Get entry by key
     */
    async getByKey(namespace, key) {
        const keyIndexKey = `${namespace}:${key}`;
        const id = this.keyIndex.get(keyIndexKey);
        if (!id)
            return null;
        return this.get(id);
    }
    /**
     * Update entry
     */
    async update(id, update) {
        const entry = this.entries.get(id);
        if (!entry)
            return null;
        // Apply updates
        if (update.content !== undefined) {
            entry.content = update.content;
            // Regenerate embedding if needed
            if (this.config.embeddingGenerator) {
                entry.embedding = await this.config.embeddingGenerator(entry.content);
            }
        }
        if (update.tags !== undefined) {
            entry.tags = update.tags;
        }
        if (update.metadata !== undefined) {
            entry.metadata = { ...entry.metadata, ...update.metadata };
        }
        if (update.accessLevel !== undefined) {
            entry.accessLevel = update.accessLevel;
        }
        if (update.expiresAt !== undefined) {
            entry.expiresAt = update.expiresAt;
        }
        if (update.references !== undefined) {
            entry.references = update.references;
        }
        entry.updatedAt = Date.now();
        entry.version++;
        // Update in AgentDB
        if (this.agentdb) {
            await this.updateInAgentDB(entry);
        }
        this.emit('entry:updated', { id });
        return entry;
    }
    /**
     * Delete entry
     */
    async delete(id) {
        const entry = this.entries.get(id);
        if (!entry)
            return false;
        // Remove from indexes
        this.entries.delete(id);
        this.unregisterIdMapping(id); // Clean up reverse lookup map
        this.namespaceIndex.get(entry.namespace)?.delete(id);
        const keyIndexKey = `${entry.namespace}:${entry.key}`;
        this.keyIndex.delete(keyIndexKey);
        // Delete from AgentDB
        if (this.agentdb) {
            await this.deleteFromAgentDB(id);
        }
        this.emit('entry:deleted', { id });
        return true;
    }
    /**
     * Query entries
     */
    async query(query) {
        const startTime = performance.now();
        let results = [];
        if (query.type === 'semantic' && (query.embedding || query.content)) {
            // Use semantic search
            const searchResults = await this.semanticSearch(query);
            results = searchResults.map((r) => r.entry);
        }
        else {
            // Fallback to in-memory filtering
            results = this.queryInMemory(query);
        }
        const duration = performance.now() - startTime;
        this.stats.queryCount++;
        this.stats.totalQueryTime += duration;
        return results;
    }
    /**
     * Semantic vector search
     */
    async search(embedding, options) {
        const startTime = performance.now();
        if (!this.agentdb) {
            // Fallback to brute-force search
            return this.bruteForceSearch(embedding, options);
        }
        try {
            // Use AgentDB HNSW search
            const results = await this.searchWithAgentDB(embedding, options);
            const duration = performance.now() - startTime;
            this.stats.searchCount++;
            this.stats.totalSearchTime += duration;
            return results;
        }
        catch (error) {
            console.error('AgentDB search failed, falling back to brute-force:', error);
            return this.bruteForceSearch(embedding, options);
        }
    }
    /**
     * Bulk insert
     */
    async bulkInsert(entries) {
        for (const entry of entries) {
            await this.store(entry);
        }
    }
    /**
     * Bulk delete
     */
    async bulkDelete(ids) {
        let deleted = 0;
        for (const id of ids) {
            if (await this.delete(id)) {
                deleted++;
            }
        }
        return deleted;
    }
    /**
     * Count entries
     */
    async count(namespace) {
        if (namespace) {
            return this.namespaceIndex.get(namespace)?.size || 0;
        }
        return this.entries.size;
    }
    /**
     * List namespaces
     */
    async listNamespaces() {
        return Array.from(this.namespaceIndex.keys());
    }
    /**
     * Clear namespace
     */
    async clearNamespace(namespace) {
        const ids = this.namespaceIndex.get(namespace);
        if (!ids)
            return 0;
        let deleted = 0;
        for (const id of ids) {
            if (await this.delete(id)) {
                deleted++;
            }
        }
        return deleted;
    }
    /**
     * Get statistics
     */
    async getStats() {
        const entriesByNamespace = {};
        for (const [namespace, ids] of this.namespaceIndex) {
            entriesByNamespace[namespace] = ids.size;
        }
        const entriesByType = {
            episodic: 0,
            semantic: 0,
            procedural: 0,
            working: 0,
            cache: 0,
        };
        for (const entry of this.entries.values()) {
            entriesByType[entry.type]++;
        }
        // Get HNSW stats if available
        let hnswStats;
        if (this.agentdb && HNSWIndex) {
            try {
                const hnsw = this.agentdb.getController('hnsw');
                if (hnsw) {
                    const stats = hnsw.getStats();
                    hnswStats = {
                        vectorCount: stats.numElements || 0,
                        memoryUsage: 0,
                        avgSearchTime: stats.avgSearchTimeMs || 0,
                        buildTime: stats.lastBuildTime || 0,
                        compressionRatio: 1.0,
                    };
                }
            }
            catch {
                // HNSW not available
            }
        }
        return {
            totalEntries: this.entries.size,
            entriesByNamespace,
            entriesByType,
            memoryUsage: this.estimateMemoryUsage(),
            hnswStats,
            avgQueryTime: this.stats.queryCount > 0
                ? this.stats.totalQueryTime / this.stats.queryCount
                : 0,
            avgSearchTime: this.stats.searchCount > 0
                ? this.stats.totalSearchTime / this.stats.searchCount
                : 0,
        };
    }
    /**
     * Health check
     */
    async healthCheck() {
        const issues = [];
        const recommendations = [];
        // Check AgentDB availability
        const storageHealth = this.agentdb
            ? { status: 'healthy', latency: 0 }
            : {
                status: 'degraded',
                latency: 0,
                message: 'AgentDB not available, using fallback',
            };
        // Check index health
        const indexHealth = { status: 'healthy', latency: 0 };
        if (!this.agentdb) {
            indexHealth.status = 'degraded';
            indexHealth.message = 'HNSW index not available';
            recommendations.push('Install agentdb for 150x-12,500x faster vector search');
        }
        // Check cache health
        const cacheHealth = { status: 'healthy', latency: 0 };
        const status = storageHealth.status === 'unhealthy' || indexHealth.status === 'unhealthy'
            ? 'unhealthy'
            : storageHealth.status === 'degraded' || indexHealth.status === 'degraded'
                ? 'degraded'
                : 'healthy';
        return {
            status,
            components: {
                storage: storageHealth,
                index: indexHealth,
                cache: cacheHealth,
            },
            timestamp: Date.now(),
            issues,
            recommendations,
        };
    }
    // ===== Private Methods =====
    /**
     * Create database schema
     */
    async createSchema() {
        if (!this.agentdb)
            return;
        const db = this.agentdb.database;
        if (!db || typeof db.run !== 'function') {
            // AgentDB doesn't expose raw database - using native API
            return;
        }
        try {
            // Create memory_entries table
            await db.run(`
      CREATE TABLE IF NOT EXISTS memory_entries (
        id TEXT PRIMARY KEY,
        key TEXT NOT NULL,
        content TEXT NOT NULL,
        embedding BLOB,
        type TEXT NOT NULL,
        namespace TEXT NOT NULL,
        tags TEXT,
        metadata TEXT,
        owner_id TEXT,
        access_level TEXT NOT NULL,
        created_at INTEGER NOT NULL,
        updated_at INTEGER NOT NULL,
        expires_at INTEGER,
        version INTEGER NOT NULL,
        references TEXT,
        access_count INTEGER DEFAULT 0,
        last_accessed_at INTEGER
      )
    `);
            // Create indexes
            await db.run('CREATE INDEX IF NOT EXISTS idx_namespace ON memory_entries(namespace)');
            await db.run('CREATE INDEX IF NOT EXISTS idx_key ON memory_entries(key)');
            await db.run('CREATE INDEX IF NOT EXISTS idx_type ON memory_entries(type)');
        }
        catch {
            // Schema creation failed - using in-memory only
        }
    }
    /**
     * Store entry in AgentDB
     */
    async storeInAgentDB(entry) {
        if (!this.agentdb)
            return;
        // Try to use agentdb's native store method if available
        try {
            if (typeof this.agentdb.store === 'function') {
                await this.agentdb.store(entry.id, {
                    key: entry.key,
                    content: entry.content,
                    embedding: entry.embedding,
                    type: entry.type,
                    namespace: entry.namespace,
                    tags: entry.tags,
                    metadata: entry.metadata,
                });
                return;
            }
            // Fallback: use database directly if available
            const db = this.agentdb.database;
            if (!db || typeof db.run !== 'function') {
                // No compatible database interface - skip agentdb storage
                // Entry is already stored in-memory
                return;
            }
            await db.run(`
      INSERT OR REPLACE INTO memory_entries
      (id, key, content, embedding, type, namespace, tags, metadata, owner_id,
       access_level, created_at, updated_at, expires_at, version, references,
       access_count, last_accessed_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `, [
                entry.id,
                entry.key,
                entry.content,
                entry.embedding ? Buffer.from(entry.embedding.buffer) : null,
                entry.type,
                entry.namespace,
                JSON.stringify(entry.tags),
                JSON.stringify(entry.metadata),
                entry.ownerId || null,
                entry.accessLevel,
                entry.createdAt,
                entry.updatedAt,
                entry.expiresAt || null,
                entry.version,
                JSON.stringify(entry.references),
                entry.accessCount,
                entry.lastAccessedAt,
            ]);
        }
        catch {
            // AgentDB storage failed - entry is already in-memory
        }
        // Add to vector index if HNSW is available
        if (entry.embedding && HNSWIndex) {
            try {
                const hnsw = this.agentdb.getController('hnsw');
                if (hnsw) {
                    // Convert string ID to number for HNSW (use hash)
                    const numericId = this.stringIdToNumeric(entry.id);
                    hnsw.addVector(numericId, entry.embedding);
                }
            }
            catch {
                // HNSW not available
            }
        }
    }
    /**
     * Get entry from AgentDB
     */
    async getFromAgentDB(id) {
        if (!this.agentdb)
            return null;
        try {
            // Try native get method first
            if (typeof this.agentdb.get === 'function') {
                const data = await this.agentdb.get(id);
                if (data)
                    return this.dataToEntry(id, data);
            }
            // Fallback to database
            const db = this.agentdb.database;
            if (!db || typeof db.get !== 'function')
                return null;
            const row = await db.get('SELECT * FROM memory_entries WHERE id = ?', [id]);
            if (!row)
                return null;
            return this.rowToEntry(row);
        }
        catch {
            return null;
        }
    }
    /**
     * Convert agentdb data to MemoryEntry
     */
    dataToEntry(id, data) {
        const now = Date.now();
        return {
            id,
            key: data.key || id,
            content: data.content || '',
            embedding: data.embedding,
            type: data.type || 'semantic',
            namespace: data.namespace || this.config.namespace,
            tags: data.tags || [],
            metadata: data.metadata || {},
            ownerId: data.ownerId,
            accessLevel: data.accessLevel || 'private',
            createdAt: data.createdAt || now,
            updatedAt: data.updatedAt || now,
            expiresAt: data.expiresAt,
            version: data.version || 1,
            references: data.references || [],
            accessCount: data.accessCount || 0,
            lastAccessedAt: data.lastAccessedAt || now,
        };
    }
    /**
     * Update entry in AgentDB
     */
    async updateInAgentDB(entry) {
        await this.storeInAgentDB(entry);
    }
    /**
     * Delete entry from AgentDB
     */
    async deleteFromAgentDB(id) {
        if (!this.agentdb)
            return;
        try {
            // Try native delete method first
            if (typeof this.agentdb.delete === 'function') {
                await this.agentdb.delete(id);
                return;
            }
            // Fallback to database
            const db = this.agentdb.database;
            if (!db || typeof db.run !== 'function')
                return;
            await db.run('DELETE FROM memory_entries WHERE id = ?', [id]);
        }
        catch {
            // Delete failed - entry removed from in-memory
        }
    }
    /**
     * Search with AgentDB HNSW
     */
    async searchWithAgentDB(embedding, options) {
        if (!this.agentdb || !HNSWIndex) {
            return [];
        }
        try {
            const hnsw = this.agentdb.getController('hnsw');
            if (!hnsw) {
                return this.bruteForceSearch(embedding, options);
            }
            const results = await hnsw.search(embedding, options.k, {
                threshold: options.threshold,
            });
            const searchResults = [];
            for (const result of results) {
                const id = this.numericIdToString(result.id);
                const entry = await this.get(id);
                if (!entry)
                    continue;
                searchResults.push({
                    entry,
                    score: result.similarity,
                    distance: result.distance,
                });
            }
            return searchResults;
        }
        catch (error) {
            console.error('HNSW search failed:', error);
            return this.bruteForceSearch(embedding, options);
        }
    }
    /**
     * Brute-force vector search fallback
     */
    bruteForceSearch(embedding, options) {
        const results = [];
        for (const entry of this.entries.values()) {
            if (!entry.embedding)
                continue;
            const score = this.cosineSimilarity(embedding, entry.embedding);
            const distance = 1 - score;
            if (options.threshold && score < options.threshold)
                continue;
            results.push({ entry, score, distance });
        }
        // Sort by score descending
        results.sort((a, b) => b.score - a.score);
        return results.slice(0, options.k);
    }
    /**
     * Semantic search helper
     */
    async semanticSearch(query) {
        let embedding = query.embedding;
        if (!embedding && query.content && this.config.embeddingGenerator) {
            embedding = await this.config.embeddingGenerator(query.content);
        }
        if (!embedding) {
            return [];
        }
        return this.search(embedding, {
            k: query.limit,
            threshold: query.threshold,
            filters: query,
        });
    }
    /**
     * In-memory query fallback
     */
    queryInMemory(query) {
        let results = Array.from(this.entries.values());
        // Apply filters
        if (query.namespace) {
            results = results.filter((e) => e.namespace === query.namespace);
        }
        if (query.key) {
            results = results.filter((e) => e.key === query.key);
        }
        if (query.keyPrefix) {
            results = results.filter((e) => e.key.startsWith(query.keyPrefix));
        }
        if (query.tags && query.tags.length > 0) {
            results = results.filter((e) => query.tags.every((tag) => e.tags.includes(tag)));
        }
        return results.slice(0, query.limit);
    }
    /**
     * Update in-memory indexes
     */
    updateIndexes(entry) {
        const namespace = entry.namespace;
        if (!this.namespaceIndex.has(namespace)) {
            this.namespaceIndex.set(namespace, new Set());
        }
        this.namespaceIndex.get(namespace).add(entry.id);
        const keyIndexKey = `${namespace}:${entry.key}`;
        this.keyIndex.set(keyIndexKey, entry.id);
    }
    /**
     * Convert DB row to MemoryEntry
     */
    rowToEntry(row) {
        return {
            id: row.id,
            key: row.key,
            content: row.content,
            embedding: row.embedding
                ? new Float32Array(new Uint8Array(row.embedding).buffer)
                : undefined,
            type: row.type,
            namespace: row.namespace,
            tags: JSON.parse(row.tags || '[]'),
            metadata: JSON.parse(row.metadata || '{}'),
            ownerId: row.owner_id,
            accessLevel: row.access_level,
            createdAt: row.created_at,
            updatedAt: row.updated_at,
            expiresAt: row.expires_at,
            version: row.version,
            references: JSON.parse(row.references || '[]'),
            accessCount: row.access_count || 0,
            lastAccessedAt: row.last_accessed_at || row.created_at,
        };
    }
    /**
     * Convert string ID to numeric for HNSW
     */
    stringIdToNumeric(id) {
        let hash = 0;
        for (let i = 0; i < id.length; i++) {
            hash = (hash << 5) - hash + id.charCodeAt(i);
            hash |= 0;
        }
        return Math.abs(hash);
    }
    /**
     * Convert numeric ID back to string using O(1) reverse lookup
     * PERFORMANCE FIX: Uses pre-built reverse map instead of O(n) linear scan
     */
    numericIdToString(numericId) {
        // Use O(1) reverse lookup map
        const stringId = this.numericToStringIdMap.get(numericId);
        if (stringId) {
            return stringId;
        }
        // Fallback for unmapped IDs
        return String(numericId);
    }
    /**
     * Register string ID in reverse lookup map
     * Called when storing entries to maintain bidirectional mapping
     */
    registerIdMapping(stringId) {
        const numericId = this.stringIdToNumeric(stringId);
        this.numericToStringIdMap.set(numericId, stringId);
    }
    /**
     * Unregister string ID from reverse lookup map
     * Called when deleting entries
     */
    unregisterIdMapping(stringId) {
        const numericId = this.stringIdToNumeric(stringId);
        this.numericToStringIdMap.delete(numericId);
    }
    /**
     * Cosine similarity (returns value in range [0, 1] where 1 = identical)
     */
    cosineSimilarity(a, b) {
        let dotProduct = 0;
        let normA = 0;
        let normB = 0;
        for (let i = 0; i < a.length; i++) {
            dotProduct += a[i] * b[i];
            normA += a[i] * a[i];
            normB += b[i] * b[i];
        }
        const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
        return magnitude === 0 ? 0 : dotProduct / magnitude;
    }
    /**
     * Estimate memory usage
     */
    estimateMemoryUsage() {
        let total = 0;
        for (const entry of this.entries.values()) {
            total += entry.content.length * 2;
            if (entry.embedding) {
                total += entry.embedding.length * 4;
            }
        }
        return total;
    }
    /**
     * Check if AgentDB is available
     */
    isAvailable() {
        return this.available;
    }
    /**
     * Get underlying AgentDB instance
     */
    getAgentDB() {
        return this.agentdb;
    }
}
export default AgentDBBackend;
//# sourceMappingURL=agentdb-backend.js.map