moflo 4.8.19 → 4.8.20

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

@@ -0,0 +1,143 @@
+/**
+ * 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/entities/memory-entry.js

@@ -0,0 +1,226 @@
+/**
+ * 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
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Memory Entry - Aggregate Root
+ *
+ * Represents a single memory entry with business logic
+ * for access tracking, expiration, and state management.
+ */
+export class MemoryEntry {
+    _id;
+    _namespace;
+    _key;
+    _value;
+    _type;
+    _vector;
+    _metadata;
+    _accessCount;
+    _lastAccessedAt;
+    _createdAt;
+    _updatedAt;
+    _status;
+    _ttl;
+    constructor(props) {
+        const now = new Date();
+        this._id = props.id ?? randomUUID();
+        this._namespace = props.namespace;
+        this._key = props.key;
+        this._value = props.value;
+        this._type = props.type;
+        this._vector = props.vector;
+        this._metadata = props.metadata ?? {};
+        this._accessCount = props.accessCount ?? 0;
+        this._lastAccessedAt = props.lastAccessedAt ?? now;
+        this._createdAt = props.createdAt ?? now;
+        this._updatedAt = props.updatedAt ?? now;
+        this._status = props.status ?? 'active';
+        this._ttl = props.ttl;
+    }
+    /**
+     * Factory method - Create new memory entry
+     */
+    static create(props) {
+        return new MemoryEntry(props);
+    }
+    /**
+     * Factory method - Reconstruct from persistence
+     */
+    static fromPersistence(props) {
+        return new MemoryEntry(props);
+    }
+    // Getters
+    get id() {
+        return this._id;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    get key() {
+        return this._key;
+    }
+    get value() {
+        return this._value;
+    }
+    get type() {
+        return this._type;
+    }
+    get vector() {
+        return this._vector;
+    }
+    get metadata() {
+        return { ...this._metadata };
+    }
+    get accessCount() {
+        return this._accessCount;
+    }
+    get lastAccessedAt() {
+        return new Date(this._lastAccessedAt);
+    }
+    get createdAt() {
+        return new Date(this._createdAt);
+    }
+    get updatedAt() {
+        return new Date(this._updatedAt);
+    }
+    get status() {
+        return this._status;
+    }
+    get ttl() {
+        return this._ttl;
+    }
+    get compositeKey() {
+        return `${this._namespace}:${this._key}`;
+    }
+    // Business Logic Methods
+    /**
+     * Record an access to this memory entry
+     */
+    recordAccess() {
+        this._accessCount++;
+        this._lastAccessedAt = new Date();
+    }
+    /**
+     * Update the value of this memory entry
+     */
+    updateValue(value) {
+        this._value = value;
+        this._updatedAt = new Date();
+    }
+    /**
+     * Update the vector embedding
+     */
+    updateVector(vector) {
+        this._vector = vector;
+        this._updatedAt = new Date();
+    }
+    /**
+     * Add or update metadata
+     */
+    setMetadata(key, value) {
+        this._metadata[key] = value;
+        this._updatedAt = new Date();
+    }
+    /**
+     * Remove metadata key
+     */
+    removeMetadata(key) {
+        delete this._metadata[key];
+        this._updatedAt = new Date();
+    }
+    /**
+     * Archive this memory entry
+     */
+    archive() {
+        this._status = 'archived';
+        this._updatedAt = new Date();
+    }
+    /**
+     * Restore archived memory entry
+     */
+    restore() {
+        if (this._status === 'archived') {
+            this._status = 'active';
+            this._updatedAt = new Date();
+        }
+    }
+    /**
+     * Mark as deleted (soft delete)
+     */
+    delete() {
+        this._status = 'deleted';
+        this._updatedAt = new Date();
+    }
+    /**
+     * Check if memory has expired based on TTL
+     */
+    isExpired() {
+        if (!this._ttl)
+            return false;
+        const expiresAt = this._createdAt.getTime() + this._ttl;
+        return Date.now() > expiresAt;
+    }
+    /**
+     * Check if memory is accessible (active and not expired)
+     */
+    isAccessible() {
+        return this._status === 'active' && !this.isExpired();
+    }
+    /**
+     * Calculate age in milliseconds
+     */
+    getAge() {
+        return Date.now() - this._createdAt.getTime();
+    }
+    /**
+     * Calculate time since last access in milliseconds
+     */
+    getTimeSinceLastAccess() {
+        return Date.now() - this._lastAccessedAt.getTime();
+    }
+    /**
+     * Check if memory is considered "hot" (frequently accessed)
+     */
+    isHot(threshold = 10) {
+        return this._accessCount >= threshold;
+    }
+    /**
+     * Check if memory is considered "cold" (not accessed recently)
+     */
+    isCold(milliseconds = 3600000) {
+        return this.getTimeSinceLastAccess() > milliseconds;
+    }
+    /**
+     * Convert to plain object for persistence
+     */
+    toPersistence() {
+        return {
+            id: this._id,
+            namespace: this._namespace,
+            key: this._key,
+            value: this._value,
+            type: this._type,
+            vector: this._vector ? Array.from(this._vector) : undefined,
+            metadata: this._metadata,
+            accessCount: this._accessCount,
+            lastAccessedAt: this._lastAccessedAt.toISOString(),
+            createdAt: this._createdAt.toISOString(),
+            updatedAt: this._updatedAt.toISOString(),
+            status: this._status,
+            ttl: this._ttl,
+        };
+    }
+    /**
+     * Convert to JSON-serializable object
+     */
+    toJSON() {
+        return this.toPersistence();
+    }
+}
+//# sourceMappingURL=memory-entry.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * 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/index.js

@@ -0,0 +1,12 @@
+/**
+ * Memory Domain Layer - Public Exports
+ *
+ * Exports all domain entities, value objects, services, and interfaces.
+ *
+ * @module v3/memory/domain
+ */
+// Entities
+export { MemoryEntry, } from './entities/memory-entry.js';
+// Domain Services
+export { MemoryDomainService, } from './services/memory-domain-service.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,102 @@
+/**
+ * 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/repositories/memory-repository.interface.js

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export {};
+//# sourceMappingURL=memory-repository.interface.js.map

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

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