moflo 4.8.16 → 4.8.19

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

@@ -1,463 +0,0 @@
-/**
- * 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/src/@claude-flow/memory/dist/agentdb-adapter.d.ts

@@ -1,165 +0,0 @@
-/**
- * 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