moflo 4.0.2 → 4.0.4

package/v3/@claude-flow/memory/dist/agent-memory-scope.test.js

@@ -0,0 +1,463 @@
+/**
+ * Tests for Agent-Scoped Memory
+ *
+ * TDD London School (mock-first) tests for the 3-scope agent memory system.
+ * Uses vi.mock for ESM-compatible fs mocking.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+// ESM-compatible mock: vi.mock is hoisted above imports automatically
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        existsSync: vi.fn(actual.existsSync),
+        readdirSync: vi.fn(actual.readdirSync),
+        statSync: vi.fn(actual.statSync),
+    };
+});
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolveAgentMemoryDir, createAgentBridge, transferKnowledge, listAgentScopes, } from './agent-memory-scope.js';
+import { createDefaultEntry } from './types.js';
+import { AutoMemoryBridge } from './auto-memory-bridge.js';
+// Cast mocked fs functions for test control
+const mockExistsSync = existsSync;
+const mockReaddirSync = readdirSync;
+const mockStatSync = statSync;
+// ===== Mock Backend =====
+function createMockBackend(entries = []) {
+    return {
+        initialize: vi.fn().mockResolvedValue(undefined),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        store: vi.fn().mockResolvedValue(undefined),
+        get: vi.fn().mockResolvedValue(null),
+        getByKey: vi.fn().mockResolvedValue(null),
+        update: vi.fn().mockResolvedValue(null),
+        delete: vi.fn().mockResolvedValue(true),
+        query: vi.fn().mockResolvedValue(entries),
+        search: vi.fn().mockResolvedValue([]),
+        bulkInsert: vi.fn().mockResolvedValue(undefined),
+        bulkDelete: vi.fn().mockResolvedValue(0),
+        count: vi.fn().mockResolvedValue(0),
+        listNamespaces: vi.fn().mockResolvedValue([]),
+        clearNamespace: vi.fn().mockResolvedValue(0),
+        getStats: vi.fn().mockResolvedValue({
+            totalEntries: 0,
+            entriesByNamespace: {},
+            entriesByType: {},
+            memoryUsage: 0,
+            avgQueryTime: 0,
+            avgSearchTime: 0,
+        }),
+        healthCheck: vi.fn().mockResolvedValue({
+            status: 'healthy',
+            components: {
+                storage: { status: 'healthy', latency: 0 },
+                index: { status: 'healthy', latency: 0 },
+                cache: { status: 'healthy', latency: 0 },
+            },
+            timestamp: Date.now(),
+            issues: [],
+            recommendations: [],
+        }),
+    };
+}
+// ===== Test Fixtures =====
+function createTestEntry(overrides = {}) {
+    const base = createDefaultEntry({
+        key: 'test-key',
+        content: 'Test content for knowledge transfer',
+        namespace: 'learnings',
+        tags: ['insight', 'architecture'],
+        metadata: {
+            confidence: 0.95,
+            category: 'architecture',
+            summary: 'Use event sourcing for state changes',
+        },
+    });
+    // When overrides.metadata is provided, use it directly (don't merge with base metadata)
+    const metadata = overrides.metadata !== undefined ? overrides.metadata : base.metadata;
+    return { ...base, ...overrides, metadata };
+}
+// ===== resolveAgentMemoryDir =====
+describe('resolveAgentMemoryDir', () => {
+    const originalHome = process.env.HOME;
+    const originalUserProfile = process.env.USERPROFILE;
+    beforeEach(() => {
+        mockExistsSync.mockReset();
+        // Default: no .git found anywhere
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        process.env.HOME = originalHome;
+        process.env.USERPROFILE = originalUserProfile;
+    });
+    it('should resolve project scope to gitRoot/.claude/agent-memory/name/', () => {
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === path.join('/workspaces/my-project', '.git');
+        });
+        const result = resolveAgentMemoryDir('coder', 'project', '/workspaces/my-project/src');
+        expect(result).toBe(path.join('/workspaces/my-project', '.claude', 'agent-memory', 'coder'));
+    });
+    it('should resolve local scope to gitRoot/.claude/agent-memory-local/name/', () => {
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === path.join('/workspaces/my-project', '.git');
+        });
+        const result = resolveAgentMemoryDir('researcher', 'local', '/workspaces/my-project/src');
+        expect(result).toBe(path.join('/workspaces/my-project', '.claude', 'agent-memory-local', 'researcher'));
+    });
+    it('should resolve user scope to ~/.claude/agent-memory/name/', () => {
+        process.env.HOME = '/home/testuser';
+        const result = resolveAgentMemoryDir('planner', 'user');
+        expect(result).toBe(path.join('/home/testuser', '.claude', 'agent-memory', 'planner'));
+    });
+    it('should sanitize agent name by replacing special characters', () => {
+        process.env.HOME = '/home/testuser';
+        const result = resolveAgentMemoryDir('my agent!@#name', 'user');
+        expect(result).toBe(path.join('/home/testuser', '.claude', 'agent-memory', 'my_agent___name'));
+    });
+    it('should handle path traversal attempts in agent name', () => {
+        process.env.HOME = '/home/testuser';
+        const result = resolveAgentMemoryDir('../../../etc/passwd', 'user');
+        expect(result).toContain('______etc_passwd');
+        expect(result).not.toContain('..');
+    });
+    it('should handle dots and slashes in agent name', () => {
+        process.env.HOME = '/home/testuser';
+        const result = resolveAgentMemoryDir('agent/with.dots', 'user');
+        expect(result).toBe(path.join('/home/testuser', '.claude', 'agent-memory', 'agent_with_dots'));
+    });
+    it('should fall back to workingDir when no git root is found', () => {
+        mockExistsSync.mockReturnValue(false);
+        const result = resolveAgentMemoryDir('coder', 'project', '/some/dir');
+        expect(result).toBe(path.join('/some/dir', '.claude', 'agent-memory', 'coder'));
+    });
+    it('should fall back to USERPROFILE when HOME is not set', () => {
+        delete process.env.HOME;
+        process.env.USERPROFILE = '/Users/testuser';
+        const result = resolveAgentMemoryDir('coder', 'user');
+        expect(result).toBe(path.join('/Users/testuser', '.claude', 'agent-memory', 'coder'));
+    });
+    it('should use cwd as fallback for project scope when workingDir is omitted', () => {
+        mockExistsSync.mockReturnValue(false);
+        const cwd = process.cwd();
+        const result = resolveAgentMemoryDir('coder', 'project');
+        expect(result).toBe(path.join(cwd, '.claude', 'agent-memory', 'coder'));
+    });
+    it('should preserve hyphens and underscores in agent name', () => {
+        process.env.HOME = '/home/testuser';
+        const result = resolveAgentMemoryDir('my-agent_01', 'user');
+        expect(result).toBe(path.join('/home/testuser', '.claude', 'agent-memory', 'my-agent_01'));
+    });
+});
+// ===== createAgentBridge =====
+describe('createAgentBridge', () => {
+    beforeEach(() => {
+        mockExistsSync.mockReset();
+        mockExistsSync.mockReturnValue(false);
+    });
+    it('should create a bridge with correct memoryDir for project scope', () => {
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === path.join('/workspaces/project', '.git');
+        });
+        const backend = createMockBackend();
+        const bridge = createAgentBridge(backend, {
+            agentName: 'coder',
+            scope: 'project',
+            workingDir: '/workspaces/project',
+        });
+        expect(bridge).toBeInstanceOf(AutoMemoryBridge);
+        expect(bridge.getMemoryDir()).toBe(path.join('/workspaces/project', '.claude', 'agent-memory', 'coder'));
+        bridge.destroy();
+    });
+    it('should create a bridge with correct memoryDir for user scope', () => {
+        const originalHome = process.env.HOME;
+        process.env.HOME = '/home/testuser';
+        const backend = createMockBackend();
+        const bridge = createAgentBridge(backend, {
+            agentName: 'reviewer',
+            scope: 'user',
+        });
+        expect(bridge).toBeInstanceOf(AutoMemoryBridge);
+        expect(bridge.getMemoryDir()).toBe(path.join('/home/testuser', '.claude', 'agent-memory', 'reviewer'));
+        bridge.destroy();
+        process.env.HOME = originalHome;
+    });
+    it('should create a bridge with correct memoryDir for local scope', () => {
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === path.join('/workspaces/project', '.git');
+        });
+        const backend = createMockBackend();
+        const bridge = createAgentBridge(backend, {
+            agentName: 'tester',
+            scope: 'local',
+            workingDir: '/workspaces/project',
+        });
+        expect(bridge).toBeInstanceOf(AutoMemoryBridge);
+        expect(bridge.getMemoryDir()).toBe(path.join('/workspaces/project', '.claude', 'agent-memory-local', 'tester'));
+        bridge.destroy();
+    });
+    it('should pass through other config options to AutoMemoryBridge', () => {
+        const backend = createMockBackend();
+        const bridge = createAgentBridge(backend, {
+            agentName: 'coder',
+            scope: 'project',
+            workingDir: '/tmp/test',
+            syncMode: 'on-session-end',
+            maxIndexLines: 100,
+            minConfidence: 0.9,
+        });
+        expect(bridge).toBeInstanceOf(AutoMemoryBridge);
+        bridge.destroy();
+    });
+});
+// ===== transferKnowledge =====
+describe('transferKnowledge', () => {
+    let targetBridge;
+    let targetBackend;
+    beforeEach(() => {
+        mockExistsSync.mockReset();
+        mockExistsSync.mockReturnValue(false);
+        targetBackend = createMockBackend();
+        targetBridge = new AutoMemoryBridge(targetBackend, {
+            memoryDir: '/tmp/test-agent-memory',
+            syncMode: 'on-session-end',
+        });
+    });
+    afterEach(() => {
+        targetBridge.destroy();
+    });
+    it('should transfer high-confidence entries', async () => {
+        const entry = createTestEntry({
+            metadata: { confidence: 0.95, category: 'architecture', summary: 'Use event sourcing' },
+        });
+        const sourceBackend = createMockBackend([entry]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+            minConfidence: 0.8,
+        });
+        expect(result.transferred).toBe(1);
+        expect(result.skipped).toBe(0);
+        expect(targetBackend.store).toHaveBeenCalled();
+    });
+    it('should skip entries below minConfidence', async () => {
+        const lowConfEntry = createTestEntry({
+            metadata: { confidence: 0.3, category: 'debugging', summary: 'Low conf item' },
+        });
+        const sourceBackend = createMockBackend([lowConfEntry]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+            minConfidence: 0.8,
+        });
+        expect(result.transferred).toBe(0);
+        expect(result.skipped).toBe(1);
+    });
+    it('should filter by categories when specified', async () => {
+        const archEntry = createTestEntry({
+            metadata: { confidence: 0.95, category: 'architecture', summary: 'Arch pattern' },
+        });
+        const secEntry = createTestEntry({
+            metadata: { confidence: 0.95, category: 'security', summary: 'Security pattern' },
+        });
+        const sourceBackend = createMockBackend([archEntry, secEntry]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+            categories: ['architecture'],
+        });
+        expect(result.transferred).toBe(1);
+        expect(result.skipped).toBe(1);
+    });
+    it('should respect maxEntries limit', async () => {
+        const entries = Array.from({ length: 10 }, (_, i) => createTestEntry({
+            key: `entry-${i}`,
+            metadata: { confidence: 0.95, category: 'architecture', summary: `Pattern ${i}` },
+        }));
+        const sourceBackend = createMockBackend(entries);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+            maxEntries: 3,
+        });
+        expect(result.transferred).toBe(3);
+    });
+    it('should handle empty source', async () => {
+        const sourceBackend = createMockBackend([]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(result.transferred).toBe(0);
+        expect(result.skipped).toBe(0);
+    });
+    it('should set transfer source metadata on insights', async () => {
+        const entry = createTestEntry({
+            metadata: { confidence: 0.95, category: 'architecture', summary: 'Test pattern' },
+        });
+        const sourceBackend = createMockBackend([entry]);
+        const recordSpy = vi.spyOn(targetBridge, 'recordInsight');
+        await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'my-namespace',
+        });
+        expect(recordSpy).toHaveBeenCalledWith(expect.objectContaining({
+            source: 'transfer:my-namespace',
+        }));
+    });
+    it('should use default category when entry has no category metadata', async () => {
+        const entry = createTestEntry({
+            metadata: { confidence: 0.95, summary: 'No category' },
+        });
+        const sourceBackend = createMockBackend([entry]);
+        const recordSpy = vi.spyOn(targetBridge, 'recordInsight');
+        await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(recordSpy).toHaveBeenCalledWith(expect.objectContaining({
+            category: 'project-patterns',
+        }));
+    });
+    it('should use first line of content as summary when metadata.summary is missing', async () => {
+        const entry = createTestEntry({
+            content: 'First line summary\nSecond line detail',
+            metadata: { confidence: 0.9 },
+        });
+        const sourceBackend = createMockBackend([entry]);
+        const recordSpy = vi.spyOn(targetBridge, 'recordInsight');
+        await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(recordSpy).toHaveBeenCalledWith(expect.objectContaining({
+            summary: 'First line summary',
+        }));
+    });
+    it('should include entries without category when no category filter is set', async () => {
+        const entry = createTestEntry({
+            metadata: { confidence: 0.95 },
+        });
+        const sourceBackend = createMockBackend([entry]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(result.transferred).toBe(1);
+    });
+    it('should default minConfidence to 0.8 when not specified', async () => {
+        const borderline = createTestEntry({
+            key: 'border',
+            metadata: { confidence: 0.79, summary: 'Borderline' },
+        });
+        const passing = createTestEntry({
+            key: 'passing',
+            metadata: { confidence: 0.81, summary: 'Passing' },
+        });
+        const sourceBackend = createMockBackend([borderline, passing]);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(result.transferred).toBe(1);
+        expect(result.skipped).toBe(1);
+    });
+    it('should default maxEntries to 20 when not specified', async () => {
+        const entries = Array.from({ length: 30 }, (_, i) => createTestEntry({
+            key: `entry-${i}`,
+            metadata: { confidence: 0.95, summary: `Pattern ${i}` },
+        }));
+        const sourceBackend = createMockBackend(entries);
+        const result = await transferKnowledge(sourceBackend, targetBridge, {
+            sourceNamespace: 'learnings',
+        });
+        expect(result.transferred).toBe(20);
+    });
+});
+// ===== listAgentScopes =====
+describe('listAgentScopes', () => {
+    const originalHome = process.env.HOME;
+    beforeEach(() => {
+        mockExistsSync.mockReset();
+        mockReaddirSync.mockReset();
+        mockStatSync.mockReset();
+        // Default: nothing exists
+        mockExistsSync.mockReturnValue(false);
+    });
+    afterEach(() => {
+        process.env.HOME = originalHome;
+    });
+    it('should return empty agents when dirs do not exist', () => {
+        process.env.HOME = '/home/testuser';
+        mockExistsSync.mockReturnValue(false);
+        const scopes = listAgentScopes('/workspaces/project');
+        expect(scopes).toHaveLength(3);
+        expect(scopes[0]).toEqual({ scope: 'project', agents: [] });
+        expect(scopes[1]).toEqual({ scope: 'local', agents: [] });
+        expect(scopes[2]).toEqual({ scope: 'user', agents: [] });
+    });
+    it('should list agents from existing directories', () => {
+        process.env.HOME = '/home/testuser';
+        // Compute the expected directories (no git root, falls back to workingDir)
+        const projectDir = path.join('/workspaces/project', '.claude', 'agent-memory');
+        const localDir = path.join('/workspaces/project', '.claude', 'agent-memory-local');
+        const userDir = path.join('/home/testuser', '.claude', 'agent-memory');
+        mockExistsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === projectDir)
+                return true;
+            if (s === localDir)
+                return true;
+            if (s === userDir)
+                return true;
+            // No .git found
+            return false;
+        });
+        mockReaddirSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === projectDir)
+                return ['coder', 'tester'];
+            if (s === localDir)
+                return ['researcher'];
+            if (s === userDir)
+                return ['planner'];
+            return [];
+        });
+        mockStatSync.mockReturnValue({ isDirectory: () => true });
+        const scopes = listAgentScopes('/workspaces/project');
+        expect(scopes[0]).toEqual({ scope: 'project', agents: ['coder', 'tester'] });
+        expect(scopes[1]).toEqual({ scope: 'local', agents: ['researcher'] });
+        expect(scopes[2]).toEqual({ scope: 'user', agents: ['planner'] });
+    });
+    it('should return all three scopes in order: project, local, user', () => {
+        mockExistsSync.mockReturnValue(false);
+        const scopes = listAgentScopes('/tmp/test');
+        expect(scopes.map((s) => s.scope)).toEqual(['project', 'local', 'user']);
+    });
+    it('should handle readdir errors gracefully', () => {
+        process.env.HOME = '/home/testuser';
+        const projectDir = path.join('/workspaces/project', '.claude', 'agent-memory');
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === projectDir;
+        });
+        mockReaddirSync.mockImplementation(() => {
+            throw new Error('Permission denied');
+        });
+        const scopes = listAgentScopes('/workspaces/project');
+        expect(scopes[0]).toEqual({ scope: 'project', agents: [] });
+    });
+    it('should skip non-directory entries', () => {
+        process.env.HOME = '/home/testuser';
+        const projectDir = path.join('/workspaces/project', '.claude', 'agent-memory');
+        mockExistsSync.mockImplementation((p) => {
+            return String(p) === projectDir;
+        });
+        mockReaddirSync.mockImplementation((p) => {
+            if (String(p) === projectDir)
+                return ['coder', 'readme.md'];
+            return [];
+        });
+        let callCount = 0;
+        mockStatSync.mockImplementation(() => {
+            callCount++;
+            if (callCount === 1) {
+                return { isDirectory: () => true };
+            }
+            return { isDirectory: () => false };
+        });
+        const scopes = listAgentScopes('/workspaces/project');
+        expect(scopes[0].agents).toEqual(['coder']);
+    });
+});
+//# sourceMappingURL=agent-memory-scope.test.js.map

package/v3/@claude-flow/memory/dist/agentdb-adapter.d.ts

@@ -0,0 +1,165 @@
+/**
+ * V3 AgentDB Adapter
+ *
+ * Unified memory backend implementation using AgentDB with HNSW indexing
+ * for 150x-12,500x faster vector search. Implements IMemoryBackend interface.
+ *
+ * @module v3/memory/agentdb-adapter
+ */
+import { EventEmitter } from 'node:events';
+import { IMemoryBackend, MemoryEntry, MemoryEntryInput, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
+/**
+ * Configuration for AgentDB Adapter
+ */
+export interface AgentDBAdapterConfig {
+    /** Vector dimensions for embeddings (default: 1536 for OpenAI) */
+    dimensions: number;
+    /** Maximum number of entries */
+    maxEntries: number;
+    /** Enable caching */
+    cacheEnabled: boolean;
+    /** Maximum cache size */
+    cacheSize: number;
+    /** Cache TTL in milliseconds */
+    cacheTtl: number;
+    /** HNSW M parameter (max connections per layer) */
+    hnswM: number;
+    /** HNSW efConstruction parameter */
+    hnswEfConstruction: number;
+    /** Default namespace */
+    defaultNamespace: string;
+    /** Embedding generator function */
+    embeddingGenerator?: EmbeddingGenerator;
+    /** Enable persistence to disk */
+    persistenceEnabled: boolean;
+    /** Persistence path */
+    persistencePath?: string;
+}
+/**
+ * AgentDB Memory Backend Adapter
+ *
+ * Provides unified memory storage with:
+ * - HNSW-based vector search (150x-12,500x faster than brute force)
+ * - LRU caching with TTL support
+ * - Namespace-based organization
+ * - Full-text and metadata filtering
+ * - Event-driven architecture
+ */
+export declare class AgentDBAdapter extends EventEmitter implements IMemoryBackend {
+    private config;
+    private entries;
+    private index;
+    private cache;
+    private namespaceIndex;
+    private keyIndex;
+    private tagIndex;
+    private initialized;
+    private stats;
+    constructor(config?: Partial<AgentDBAdapterConfig>);
+    /**
+     * Initialize the adapter
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the adapter
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Store a memory entry
+     */
+    store(entry: MemoryEntry): Promise<void>;
+    /**
+     * Get a memory entry by ID
+     */
+    get(id: string): Promise<MemoryEntry | null>;
+    /**
+     * Get a memory entry by key within a namespace
+     */
+    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /**
+     * Update a memory entry
+     */
+    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    /**
+     * Delete a memory entry
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Query memory entries with filters
+     */
+    query(query: MemoryQuery): Promise<MemoryEntry[]>;
+    /**
+     * Semantic vector search
+     */
+    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Bulk insert entries (OPTIMIZED: 2-3x faster with batched operations)
+     *
+     * Performance improvements:
+     * - Parallel embedding generation
+     * - Batched index updates
+     * - Deferred cache population
+     * - Single event emission
+     */
+    bulkInsert(entries: MemoryEntry[], options?: {
+        batchSize?: number;
+    }): Promise<void>;
+    /**
+     * Bulk delete entries (OPTIMIZED: parallel deletion)
+     */
+    bulkDelete(ids: string[]): Promise<number>;
+    /**
+     * Bulk get entries by IDs (OPTIMIZED: parallel fetch with cache)
+     */
+    bulkGet(ids: string[]): Promise<Map<string, MemoryEntry | null>>;
+    /**
+     * Bulk update entries (OPTIMIZED: batched updates)
+     */
+    bulkUpdate(updates: Array<{
+        id: string;
+        update: MemoryEntryUpdate;
+    }>): Promise<Map<string, MemoryEntry | null>>;
+    /**
+     * Get entry count
+     */
+    count(namespace?: string): Promise<number>;
+    /**
+     * List all namespaces
+     */
+    listNamespaces(): Promise<string[]>;
+    /**
+     * Clear all entries in a namespace
+     */
+    clearNamespace(namespace: string): Promise<number>;
+    /**
+     * Get backend statistics
+     */
+    getStats(): Promise<BackendStats>;
+    /**
+     * Perform health check
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Store a new entry from input
+     */
+    storeEntry(input: MemoryEntryInput): Promise<MemoryEntry>;
+    /**
+     * Semantic search by content string
+     */
+    semanticSearch(content: string, k?: number, threshold?: number): Promise<SearchResult[]>;
+    private queryByPrefix;
+    private queryByTags;
+    private querySemanticWithFilters;
+    private queryWithFilters;
+    private applyFilters;
+    private updateAccessStats;
+    private estimateMemoryUsage;
+    private estimateEntrySize;
+    private checkStorageHealth;
+    private checkIndexHealth;
+    private checkCacheHealth;
+    private loadFromDisk;
+    private saveToDisk;
+}
+export default AgentDBAdapter;
+//# sourceMappingURL=agentdb-adapter.d.ts.map