moflo 4.8.30 → 4.8.32

package/src/@claude-flow/memory/dist/domain/entities/memory-entry.d.ts

@@ -1,143 +0,0 @@
-/**
- * Memory Entry Entity - Domain Layer
- *
- * Core domain entity representing a stored memory item.
- * Implements DDD principles with encapsulated business logic.
- *
- * @module v3/memory/domain/entities
- */
-/**
- * Memory entry types
- */
-export type MemoryType = 'semantic' | 'episodic' | 'procedural' | 'working';
-/**
- * Memory entry status
- */
-export type MemoryStatus = 'active' | 'archived' | 'deleted';
-/**
- * Memory entry properties
- */
-export interface MemoryEntryProps {
-    id?: string;
-    namespace: string;
-    key: string;
-    value: unknown;
-    type: MemoryType;
-    vector?: Float32Array;
-    metadata?: Record<string, unknown>;
-    accessCount?: number;
-    lastAccessedAt?: Date;
-    createdAt?: Date;
-    updatedAt?: Date;
-    status?: MemoryStatus;
-    ttl?: number;
-}
-/**
- * Memory Entry - Aggregate Root
- *
- * Represents a single memory entry with business logic
- * for access tracking, expiration, and state management.
- */
-export declare class MemoryEntry {
-    private _id;
-    private _namespace;
-    private _key;
-    private _value;
-    private _type;
-    private _vector?;
-    private _metadata;
-    private _accessCount;
-    private _lastAccessedAt;
-    private _createdAt;
-    private _updatedAt;
-    private _status;
-    private _ttl?;
-    private constructor();
-    /**
-     * Factory method - Create new memory entry
-     */
-    static create(props: MemoryEntryProps): MemoryEntry;
-    /**
-     * Factory method - Reconstruct from persistence
-     */
-    static fromPersistence(props: MemoryEntryProps): MemoryEntry;
-    get id(): string;
-    get namespace(): string;
-    get key(): string;
-    get value(): unknown;
-    get type(): MemoryType;
-    get vector(): Float32Array | undefined;
-    get metadata(): Record<string, unknown>;
-    get accessCount(): number;
-    get lastAccessedAt(): Date;
-    get createdAt(): Date;
-    get updatedAt(): Date;
-    get status(): MemoryStatus;
-    get ttl(): number | undefined;
-    get compositeKey(): string;
-    /**
-     * Record an access to this memory entry
-     */
-    recordAccess(): void;
-    /**
-     * Update the value of this memory entry
-     */
-    updateValue(value: unknown): void;
-    /**
-     * Update the vector embedding
-     */
-    updateVector(vector: Float32Array): void;
-    /**
-     * Add or update metadata
-     */
-    setMetadata(key: string, value: unknown): void;
-    /**
-     * Remove metadata key
-     */
-    removeMetadata(key: string): void;
-    /**
-     * Archive this memory entry
-     */
-    archive(): void;
-    /**
-     * Restore archived memory entry
-     */
-    restore(): void;
-    /**
-     * Mark as deleted (soft delete)
-     */
-    delete(): void;
-    /**
-     * Check if memory has expired based on TTL
-     */
-    isExpired(): boolean;
-    /**
-     * Check if memory is accessible (active and not expired)
-     */
-    isAccessible(): boolean;
-    /**
-     * Calculate age in milliseconds
-     */
-    getAge(): number;
-    /**
-     * Calculate time since last access in milliseconds
-     */
-    getTimeSinceLastAccess(): number;
-    /**
-     * Check if memory is considered "hot" (frequently accessed)
-     */
-    isHot(threshold?: number): boolean;
-    /**
-     * Check if memory is considered "cold" (not accessed recently)
-     */
-    isCold(milliseconds?: number): boolean;
-    /**
-     * Convert to plain object for persistence
-     */
-    toPersistence(): Record<string, unknown>;
-    /**
-     * Convert to JSON-serializable object
-     */
-    toJSON(): Record<string, unknown>;
-}
-//# sourceMappingURL=memory-entry.d.ts.map

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

@@ -1,11 +0,0 @@
-/**
- * Memory Domain Layer - Public Exports
- *
- * Exports all domain entities, value objects, services, and interfaces.
- *
- * @module v3/memory/domain
- */
-export { MemoryEntry, type MemoryType, type MemoryStatus, type MemoryEntryProps, } from './entities/memory-entry.js';
-export { type IMemoryRepository, type MemoryQueryOptions, type VectorSearchOptions, type VectorSearchResult, type BulkOperationResult, type MemoryStatistics, } from './repositories/memory-repository.interface.js';
-export { MemoryDomainService, type ConsolidationStrategy, type ConsolidationOptions, type ConsolidationResult, type DeduplicationResult, type NamespaceAnalysis, } from './services/memory-domain-service.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/memory/dist/domain/repositories/memory-repository.interface.d.ts

@@ -1,102 +0,0 @@
-/**
- * Memory Repository Interface - Domain Layer
- *
- * Defines the contract for memory persistence.
- * Following DDD, the interface belongs to the domain layer
- * while implementations belong to infrastructure.
- *
- * @module v3/memory/domain/repositories
- */
-import { MemoryEntry, MemoryType, MemoryStatus } from '../entities/memory-entry.js';
-/**
- * Query options for memory retrieval
- */
-export interface MemoryQueryOptions {
-    namespace?: string;
-    type?: MemoryType;
-    status?: MemoryStatus;
-    limit?: number;
-    offset?: number;
-    orderBy?: 'createdAt' | 'updatedAt' | 'accessCount' | 'lastAccessedAt';
-    orderDirection?: 'asc' | 'desc';
-}
-/**
- * Vector search options
- */
-export interface VectorSearchOptions {
-    vector: Float32Array;
-    namespace?: string;
-    limit?: number;
-    threshold?: number;
-    type?: MemoryType;
-}
-/**
- * Vector search result
- */
-export interface VectorSearchResult {
-    entry: MemoryEntry;
-    similarity: number;
-    distance: number;
-}
-/**
- * Bulk operation result
- */
-export interface BulkOperationResult {
-    success: number;
-    failed: number;
-    errors: Array<{
-        id: string;
-        error: string;
-    }>;
-}
-/**
- * Memory statistics
- */
-export interface MemoryStatistics {
-    totalEntries: number;
-    activeEntries: number;
-    archivedEntries: number;
-    deletedEntries: number;
-    totalSize: number;
-    entriesByNamespace: Record<string, number>;
-    entriesByType: Record<MemoryType, number>;
-    averageAccessCount: number;
-    hottestEntries: string[];
-    coldestEntries: string[];
-}
-/**
- * Memory Repository Interface
- *
- * Defines all operations for memory persistence.
- * Implementations can use SQLite, AgentDB, or hybrid backends.
- */
-export interface IMemoryRepository {
-    save(entry: MemoryEntry): Promise<void>;
-    findById(id: string): Promise<MemoryEntry | null>;
-    findByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
-    findByCompositeKey(compositeKey: string): Promise<MemoryEntry | null>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    saveMany(entries: MemoryEntry[]): Promise<BulkOperationResult>;
-    findByIds(ids: string[]): Promise<MemoryEntry[]>;
-    deleteMany(ids: string[]): Promise<BulkOperationResult>;
-    findAll(options?: MemoryQueryOptions): Promise<MemoryEntry[]>;
-    findByNamespace(namespace: string, options?: Omit<MemoryQueryOptions, 'namespace'>): Promise<MemoryEntry[]>;
-    findByType(type: MemoryType, options?: Omit<MemoryQueryOptions, 'type'>): Promise<MemoryEntry[]>;
-    findByStatus(status: MemoryStatus, options?: Omit<MemoryQueryOptions, 'status'>): Promise<MemoryEntry[]>;
-    searchByVector(options: VectorSearchOptions): Promise<VectorSearchResult[]>;
-    findSimilar(entryId: string, limit?: number): Promise<VectorSearchResult[]>;
-    findExpired(): Promise<MemoryEntry[]>;
-    deleteExpired(): Promise<number>;
-    findCold(milliseconds: number): Promise<MemoryEntry[]>;
-    archiveCold(milliseconds: number): Promise<number>;
-    getStatistics(): Promise<MemoryStatistics>;
-    count(options?: MemoryQueryOptions): Promise<number>;
-    listNamespaces(): Promise<string[]>;
-    deleteNamespace(namespace: string): Promise<number>;
-    getNamespaceSize(namespace: string): Promise<number>;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    clear(): Promise<void>;
-}
-//# sourceMappingURL=memory-repository.interface.d.ts.map

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

@@ -1,105 +0,0 @@
-/**
- * Memory Domain Service - Domain Layer
- *
- * Contains domain logic that doesn't naturally fit within a single entity.
- * Coordinates between multiple memory entries and enforces domain rules.
- *
- * @module v3/memory/domain/services
- */
-import { MemoryEntry, MemoryType } from '../entities/memory-entry.js';
-import { IMemoryRepository, VectorSearchResult } from '../repositories/memory-repository.interface.js';
-/**
- * Memory consolidation strategy
- */
-export type ConsolidationStrategy = 'merge' | 'dedupe' | 'prune' | 'summarize';
-/**
- * Memory consolidation options
- */
-export interface ConsolidationOptions {
-    strategy: ConsolidationStrategy;
-    namespace?: string;
-    threshold?: number;
-    maxAge?: number;
-    keepHot?: boolean;
-}
-/**
- * Consolidation result
- */
-export interface ConsolidationResult {
-    processed: number;
-    consolidated: number;
-    removed: number;
-    newEntries: MemoryEntry[];
-}
-/**
- * Memory deduplication result
- */
-export interface DeduplicationResult {
-    duplicatesFound: number;
-    duplicatesRemoved: number;
-    groupsProcessed: number;
-}
-/**
- * Memory namespace statistics
- */
-export interface NamespaceAnalysis {
-    namespace: string;
-    totalEntries: number;
-    activeEntries: number;
-    totalSize: number;
-    averageAccessCount: number;
-    oldestEntry: Date;
-    newestEntry: Date;
-    typeDistribution: Record<MemoryType, number>;
-}
-/**
- * Memory Domain Service
- *
- * Provides domain-level operations that span multiple entities.
- * Implements business rules for memory management.
- */
-export declare class MemoryDomainService {
-    private readonly repository;
-    constructor(repository: IMemoryRepository);
-    /**
-     * Store a new memory with automatic type detection
-     */
-    storeWithTypeDetection(namespace: string, key: string, value: unknown, vector?: Float32Array): Promise<MemoryEntry>;
-    /**
-     * Retrieve and record access
-     */
-    retrieveWithAccessTracking(namespace: string, key: string): Promise<MemoryEntry | null>;
-    /**
-     * Search for similar memories and record access
-     */
-    searchSimilarWithTracking(vector: Float32Array, namespace?: string, limit?: number): Promise<VectorSearchResult[]>;
-    /**
-     * Consolidate memories based on strategy
-     */
-    consolidate(options: ConsolidationOptions): Promise<ConsolidationResult>;
-    /**
-     * Detect memory type based on value structure
-     */
-    private detectMemoryType;
-    /**
-     * Prune old, rarely accessed memories
-     */
-    private pruneOldMemories;
-    /**
-     * Find and remove duplicate memories
-     */
-    private deduplicateMemories;
-    /**
-     * Merge related memories into consolidated entries
-     */
-    private mergeRelatedMemories;
-    /**
-     * Merge multiple entries into one
-     */
-    private mergeEntries;
-    /**
-     * Analyze a namespace
-     */
-    analyzeNamespace(namespace: string): Promise<NamespaceAnalysis>;
-}
-//# sourceMappingURL=memory-domain-service.d.ts.map

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

@@ -1,111 +0,0 @@
-/**
- * V3 HNSW Vector Index
- *
- * High-performance Hierarchical Navigable Small World (HNSW) index for
- * 150x-12,500x faster vector similarity search compared to brute force.
- *
- * OPTIMIZATIONS:
- * - BinaryMinHeap/BinaryMaxHeap for O(log n) operations (vs O(n log n) Array.sort)
- * - Pre-normalized vectors for O(1) cosine similarity (no sqrt needed)
- * - Bounded max-heap for efficient top-k tracking
- *
- * @module v3/memory/hnsw-index
- */
-import { EventEmitter } from 'node:events';
-import { HNSWConfig, HNSWStats } from './types.js';
-/**
- * HNSW Index implementation for ultra-fast vector similarity search
- *
- * Performance characteristics:
- * - Search: O(log n) approximate nearest neighbor
- * - Insert: O(log n) amortized
- * - Memory: O(n * M * L) where M is max connections, L is layers
- */
-export declare class HNSWIndex extends EventEmitter {
-    private config;
-    private nodes;
-    private entryPoint;
-    private maxLevel;
-    private levelMult;
-    private stats;
-    private quantizer;
-    constructor(config?: Partial<HNSWConfig>);
-    /**
-     * Add a vector to the index
-     */
-    addPoint(id: string, vector: Float32Array): Promise<void>;
-    /**
-     * Search for k nearest neighbors
-     */
-    search(query: Float32Array, k: number, ef?: number): Promise<Array<{
-        id: string;
-        distance: number;
-    }>>;
-    /**
-     * Search with filters applied post-retrieval
-     */
-    searchWithFilters(query: Float32Array, k: number, filter: (id: string) => boolean, ef?: number): Promise<Array<{
-        id: string;
-        distance: number;
-    }>>;
-    /**
-     * Remove a point from the index
-     */
-    removePoint(id: string): Promise<boolean>;
-    /**
-     * Rebuild the index from scratch
-     */
-    rebuild(entries: Array<{
-        id: string;
-        vector: Float32Array;
-    }>): Promise<void>;
-    /**
-     * Get index statistics
-     */
-    getStats(): HNSWStats;
-    /**
-     * Clear the index
-     */
-    clear(): void;
-    /**
-     * Check if an ID exists in the index
-     */
-    has(id: string): boolean;
-    /**
-     * Get the number of vectors in the index
-     */
-    get size(): number;
-    private mergeConfig;
-    private getRandomLevel;
-    private insertNode;
-    private searchLayer;
-    /**
-     * OPTIMIZED searchLayer using heap-based priority queues
-     * Performance: O(log n) per operation vs O(n log n) for Array.sort()
-     * Expected speedup: 3-5x for large result sets
-     */
-    private searchLayerOptimized;
-    private selectNeighbors;
-    private pruneConnections;
-    private distance;
-    private cosineDistance;
-    /**
-     * OPTIMIZED: Cosine distance using pre-normalized vectors
-     * Only requires dot product (no sqrt operations)
-     * Performance: O(n) with ~2x speedup over standard cosine
-     */
-    private cosineDistanceNormalized;
-    /**
-     * Normalize a vector to unit length for O(1) cosine similarity
-     */
-    private normalizeVector;
-    /**
-     * OPTIMIZED distance calculation that uses pre-normalized vectors when available
-     */
-    private distanceOptimized;
-    private euclideanDistance;
-    private dotProductDistance;
-    private manhattanDistance;
-}
-export default HNSWIndex;
-//# sourceMappingURL=hnsw-index.d.ts.map

package/src/@claude-flow/memory/dist/hnsw-lite.d.ts

@@ -1,23 +0,0 @@
-export interface HnswSearchResult {
-    id: string;
-    score: number;
-}
-export declare class HnswLite {
-    private vectors;
-    private neighbors;
-    private readonly dimensions;
-    private readonly maxNeighbors;
-    private readonly efConstruction;
-    private readonly metric;
-    constructor(dimensions: number, m: number, efConstruction: number, metric: string);
-    get size(): number;
-    add(id: string, vector: Float32Array): void;
-    remove(id: string): void;
-    search(query: Float32Array, k: number, threshold?: number): HnswSearchResult[];
-    private bruteForce;
-    private findNearest;
-    private pruneNeighbors;
-    private similarity;
-}
-export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
-//# sourceMappingURL=hnsw-lite.d.ts.map