moflo 4.8.31 → 4.8.32

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

package/src/@claude-flow/memory/dist/agentdb-backend.d.ts

@@ -1,212 +0,0 @@
-/**
- * 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)
- *
- * @module v3/memory/agentdb-backend
- */
-import { EventEmitter } from 'node:events';
-import { IMemoryBackend, MemoryEntry, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
-/**
- * Configuration for AgentDB Backend
- */
-export interface AgentDBBackendConfig {
-    /** Database path for persistence */
-    dbPath?: string;
-    /** Namespace for memory organization */
-    namespace?: string;
-    /** Force WASM backend (skip native hnswlib) */
-    forceWasm?: boolean;
-    /** Vector backend: 'auto', 'ruvector', 'hnswlib' */
-    vectorBackend?: 'auto' | 'ruvector' | 'hnswlib';
-    /** Vector dimensions (default: 1536) */
-    vectorDimension?: number;
-    /** HNSW M parameter */
-    hnswM?: number;
-    /** HNSW efConstruction parameter */
-    hnswEfConstruction?: number;
-    /** HNSW efSearch parameter */
-    hnswEfSearch?: number;
-    /** Enable caching */
-    cacheEnabled?: boolean;
-    /** Embedding generator function */
-    embeddingGenerator?: EmbeddingGenerator;
-    /** Maximum entries */
-    maxEntries?: number;
-}
-/**
- * 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
- */
-export declare class AgentDBBackend extends EventEmitter implements IMemoryBackend {
-    private config;
-    private agentdb;
-    private initialized;
-    private available;
-    private entries;
-    private namespaceIndex;
-    private keyIndex;
-    private numericToStringIdMap;
-    private stats;
-    constructor(config?: AgentDBBackendConfig);
-    /**
-     * Initialize AgentDB
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown AgentDB
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Store a memory entry
-     */
-    store(entry: MemoryEntry): Promise<void>;
-    /**
-     * Get entry by ID
-     */
-    get(id: string): Promise<MemoryEntry | null>;
-    /**
-     * Get entry by key
-     */
-    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    /**
-     * Update entry
-     */
-    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
-    /**
-     * Delete entry
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Query entries
-     */
-    query(query: MemoryQuery): Promise<MemoryEntry[]>;
-    /**
-     * Semantic vector search
-     */
-    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
-    /**
-     * Bulk insert
-     */
-    bulkInsert(entries: MemoryEntry[]): Promise<void>;
-    /**
-     * Bulk delete
-     */
-    bulkDelete(ids: string[]): Promise<number>;
-    /**
-     * Count entries
-     */
-    count(namespace?: string): Promise<number>;
-    /**
-     * List namespaces
-     */
-    listNamespaces(): Promise<string[]>;
-    /**
-     * Clear namespace
-     */
-    clearNamespace(namespace: string): Promise<number>;
-    /**
-     * Get statistics
-     */
-    getStats(): Promise<BackendStats>;
-    /**
-     * Health check
-     */
-    healthCheck(): Promise<HealthCheckResult>;
-    /**
-     * Create database schema
-     */
-    private createSchema;
-    /**
-     * Store entry in AgentDB
-     */
-    private storeInAgentDB;
-    /**
-     * Get entry from AgentDB
-     */
-    private getFromAgentDB;
-    /**
-     * Convert agentdb data to MemoryEntry
-     */
-    private dataToEntry;
-    /**
-     * Update entry in AgentDB
-     */
-    private updateInAgentDB;
-    /**
-     * Delete entry from AgentDB
-     */
-    private deleteFromAgentDB;
-    /**
-     * Search with AgentDB HNSW
-     */
-    private searchWithAgentDB;
-    /**
-     * Brute-force vector search fallback
-     */
-    private bruteForceSearch;
-    /**
-     * Semantic search helper
-     */
-    private semanticSearch;
-    /**
-     * In-memory query fallback
-     */
-    private queryInMemory;
-    /**
-     * Update in-memory indexes
-     */
-    private updateIndexes;
-    /**
-     * Convert DB row to MemoryEntry
-     */
-    private rowToEntry;
-    /**
-     * Convert string ID to numeric for HNSW
-     */
-    private stringIdToNumeric;
-    /**
-     * Convert numeric ID back to string using O(1) reverse lookup
-     * PERFORMANCE FIX: Uses pre-built reverse map instead of O(n) linear scan
-     */
-    private numericIdToString;
-    /**
-     * Register string ID in reverse lookup map
-     * Called when storing entries to maintain bidirectional mapping
-     */
-    private registerIdMapping;
-    /**
-     * Unregister string ID from reverse lookup map
-     * Called when deleting entries
-     */
-    private unregisterIdMapping;
-    /**
-     * Cosine similarity (returns value in range [0, 1] where 1 = identical)
-     */
-    private cosineSimilarity;
-    /**
-     * Estimate memory usage
-     */
-    private estimateMemoryUsage;
-    /**
-     * Check if AgentDB is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Get underlying AgentDB instance
-     */
-    getAgentDB(): any;
-}
-export default AgentDBBackend;
-//# sourceMappingURL=agentdb-backend.d.ts.map

package/src/@claude-flow/memory/dist/agentdb-backend.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * AgentDB Backend Tests
- *
- * Tests for agentdb@2.0.0-alpha.3.4 integration with V3 memory system
- */
-export {};
-//# sourceMappingURL=agentdb-backend.test.d.ts.map

package/src/@claude-flow/memory/dist/application/commands/delete-memory.command.d.ts

@@ -1,65 +0,0 @@
-/**
- * Delete Memory Command - Application Layer (CQRS)
- *
- * Command for deleting memory entries.
- * Supports soft delete and hard delete.
- *
- * @module v3/memory/application/commands
- */
-import { IMemoryRepository } from '../../domain/repositories/memory-repository.interface.js';
-/**
- * Delete Memory Command Input
- */
-export interface DeleteMemoryInput {
-    id?: string;
-    namespace?: string;
-    key?: string;
-    hardDelete?: boolean;
-}
-/**
- * Delete Memory Command Result
- */
-export interface DeleteMemoryResult {
-    success: boolean;
-    deleted: boolean;
-    entryId?: string;
-    wasHardDelete: boolean;
-}
-/**
- * Delete Memory Command Handler
- */
-export declare class DeleteMemoryCommandHandler {
-    private readonly repository;
-    constructor(repository: IMemoryRepository);
-    execute(input: DeleteMemoryInput): Promise<DeleteMemoryResult>;
-}
-/**
- * Bulk Delete Command Input
- */
-export interface BulkDeleteMemoryInput {
-    ids?: string[];
-    namespace?: string;
-    olderThan?: Date;
-    hardDelete?: boolean;
-}
-/**
- * Bulk Delete Command Result
- */
-export interface BulkDeleteMemoryResult {
-    success: boolean;
-    deletedCount: number;
-    failedCount: number;
-    errors: Array<{
-        id: string;
-        error: string;
-    }>;
-}
-/**
- * Bulk Delete Memory Command Handler
- */
-export declare class BulkDeleteMemoryCommandHandler {
-    private readonly repository;
-    constructor(repository: IMemoryRepository);
-    execute(input: BulkDeleteMemoryInput): Promise<BulkDeleteMemoryResult>;
-}
-//# sourceMappingURL=delete-memory.command.d.ts.map

package/src/@claude-flow/memory/dist/application/commands/store-memory.command.d.ts

@@ -1,48 +0,0 @@
-/**
- * Store Memory Command - Application Layer (CQRS)
- *
- * Command for storing a new memory entry.
- * Implements CQRS pattern per ADR-002.
- *
- * @module v3/memory/application/commands
- */
-import { MemoryEntry, MemoryType } from '../../domain/entities/memory-entry.js';
-import { IMemoryRepository } from '../../domain/repositories/memory-repository.interface.js';
-import { MemoryDomainService } from '../../domain/services/memory-domain-service.js';
-/**
- * Store Memory Command Input
- */
-export interface StoreMemoryInput {
-    namespace: string;
-    key: string;
-    value: unknown;
-    type?: MemoryType;
-    vector?: Float32Array;
-    metadata?: Record<string, unknown>;
-    ttl?: number;
-}
-/**
- * Store Memory Command Result
- */
-export interface StoreMemoryResult {
-    success: boolean;
-    entryId: string;
-    entry: MemoryEntry;
-    isUpdate: boolean;
-}
-/**
- * Store Memory Command Handler
- *
- * Handles the command to store a memory entry.
- * Coordinates between domain services and repository.
- */
-export declare class StoreMemoryCommandHandler {
-    private readonly repository;
-    private readonly domainService;
-    constructor(repository: IMemoryRepository, domainService: MemoryDomainService);
-    /**
-     * Execute the store memory command
-     */
-    execute(input: StoreMemoryInput): Promise<StoreMemoryResult>;
-}
-//# sourceMappingURL=store-memory.command.d.ts.map

package/src/@claude-flow/memory/dist/application/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Memory Application Layer - Public Exports
- *
- * Exports all application services, commands, and queries.
- *
- * @module v3/memory/application
- */
-export { StoreMemoryCommandHandler, type StoreMemoryInput, type StoreMemoryResult, } from './commands/store-memory.command.js';
-export { DeleteMemoryCommandHandler, BulkDeleteMemoryCommandHandler, type DeleteMemoryInput, type DeleteMemoryResult, type BulkDeleteMemoryInput, type BulkDeleteMemoryResult, } from './commands/delete-memory.command.js';
-export { SearchMemoryQueryHandler, GetMemoryByKeyQueryHandler, type SearchMemoryInput, type SearchMemoryResult, type GetMemoryByKeyInput, type GetMemoryByKeyResult, } from './queries/search-memory.query.js';
-export { MemoryApplicationService } from './services/memory-application-service.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/memory/dist/application/queries/search-memory.query.d.ts

@@ -1,72 +0,0 @@
-/**
- * Search Memory Query - Application Layer (CQRS)
- *
- * Query for searching memory entries.
- * Supports text search, vector search, and filtering.
- *
- * @module v3/memory/application/queries
- */
-import { MemoryEntry, MemoryType, MemoryStatus } from '../../domain/entities/memory-entry.js';
-import { IMemoryRepository } from '../../domain/repositories/memory-repository.interface.js';
-/**
- * Search Memory Query Input
- */
-export interface SearchMemoryInput {
-    vector?: Float32Array;
-    similarityThreshold?: number;
-    namespace?: string;
-    type?: MemoryType;
-    status?: MemoryStatus;
-    limit?: number;
-    offset?: number;
-    orderBy?: 'createdAt' | 'updatedAt' | 'accessCount' | 'lastAccessedAt';
-    orderDirection?: 'asc' | 'desc';
-    textQuery?: string;
-    trackAccess?: boolean;
-}
-/**
- * Search Memory Query Result
- */
-export interface SearchMemoryResult {
-    entries: MemoryEntry[];
-    total: number;
-    hasMore: boolean;
-    searchType: 'vector' | 'filter' | 'text';
-    similarities?: number[];
-}
-/**
- * Search Memory Query Handler
- */
-export declare class SearchMemoryQueryHandler {
-    private readonly repository;
-    constructor(repository: IMemoryRepository);
-    execute(input: SearchMemoryInput): Promise<SearchMemoryResult>;
-    private executeVectorSearch;
-    private executeTextSearch;
-    private executeFilterSearch;
-    private trackEntryAccess;
-}
-/**
- * Get Memory By Key Query Input
- */
-export interface GetMemoryByKeyInput {
-    namespace: string;
-    key: string;
-    trackAccess?: boolean;
-}
-/**
- * Get Memory By Key Query Result
- */
-export interface GetMemoryByKeyResult {
-    found: boolean;
-    entry?: MemoryEntry;
-}
-/**
- * Get Memory By Key Query Handler
- */
-export declare class GetMemoryByKeyQueryHandler {
-    private readonly repository;
-    constructor(repository: IMemoryRepository);
-    execute(input: GetMemoryByKeyInput): Promise<GetMemoryByKeyResult>;
-}
-//# sourceMappingURL=search-memory.query.d.ts.map

package/src/@claude-flow/memory/dist/application/services/memory-application-service.d.ts

@@ -1,121 +0,0 @@
-/**
- * Memory Application Service - Application Layer
- *
- * Orchestrates use cases and coordinates between domain and infrastructure.
- * Provides a simplified interface for external consumers.
- *
- * @module v3/memory/application/services
- */
-import { MemoryEntry, MemoryType } from '../../domain/entities/memory-entry.js';
-import { IMemoryRepository, VectorSearchResult, MemoryStatistics } from '../../domain/repositories/memory-repository.interface.js';
-import { ConsolidationOptions, ConsolidationResult } from '../../domain/services/memory-domain-service.js';
-import { StoreMemoryInput } from '../commands/store-memory.command.js';
-import { SearchMemoryInput } from '../queries/search-memory.query.js';
-/**
- * Memory Application Service
- *
- * Main entry point for memory operations.
- * Coordinates commands and queries with domain services.
- */
-export declare class MemoryApplicationService {
-    private readonly repository;
-    private readonly domainService;
-    private readonly storeHandler;
-    private readonly deleteHandler;
-    private readonly bulkDeleteHandler;
-    private readonly searchHandler;
-    private readonly getByKeyHandler;
-    constructor(repository: IMemoryRepository);
-    /**
-     * Store a memory entry
-     */
-    store(input: StoreMemoryInput): Promise<MemoryEntry>;
-    /**
-     * Store multiple memory entries
-     */
-    storeMany(inputs: StoreMemoryInput[]): Promise<MemoryEntry[]>;
-    /**
-     * Get a memory entry by namespace and key
-     */
-    get(namespace: string, key: string): Promise<MemoryEntry | null>;
-    /**
-     * Get a memory entry by ID
-     */
-    getById(id: string): Promise<MemoryEntry | null>;
-    /**
-     * Search memory entries
-     */
-    search(input: SearchMemoryInput): Promise<{
-        entries: MemoryEntry[];
-        total: number;
-        hasMore: boolean;
-    }>;
-    /**
-     * Search by vector similarity
-     */
-    searchByVector(vector: Float32Array, options?: {
-        namespace?: string;
-        limit?: number;
-        threshold?: number;
-    }): Promise<VectorSearchResult[]>;
-    /**
-     * Get all entries in a namespace
-     */
-    getNamespace(namespace: string): Promise<MemoryEntry[]>;
-    /**
-     * List all namespaces
-     */
-    listNamespaces(): Promise<string[]>;
-    /**
-     * Delete a memory entry by namespace and key
-     */
-    delete(namespace: string, key: string, hardDelete?: boolean): Promise<boolean>;
-    /**
-     * Delete a memory entry by ID
-     */
-    deleteById(id: string, hardDelete?: boolean): Promise<boolean>;
-    /**
-     * Delete all entries in a namespace
-     */
-    deleteNamespace(namespace: string, hardDelete?: boolean): Promise<number>;
-    /**
-     * Clear all memory entries
-     */
-    clear(): Promise<void>;
-    /**
-     * Consolidate memories using specified strategy
-     */
-    consolidate(options: ConsolidationOptions): Promise<ConsolidationResult>;
-    /**
-     * Clean up expired memories
-     */
-    cleanupExpired(): Promise<number>;
-    /**
-     * Archive cold (rarely accessed) memories
-     */
-    archiveCold(milliseconds?: number): Promise<number>;
-    /**
-     * Get memory statistics
-     */
-    getStatistics(): Promise<MemoryStatistics>;
-    /**
-     * Count entries matching criteria
-     */
-    count(options?: {
-        namespace?: string;
-        type?: MemoryType;
-    }): Promise<number>;
-    /**
-     * Analyze a namespace
-     */
-    analyzeNamespace(namespace: string): Promise<import("../../domain/index.js").NamespaceAnalysis>;
-    /**
-     * Initialize the memory service
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the memory service
-     */
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=memory-application-service.d.ts.map