moflo 4.8.16 → 4.8.19

package/src/@claude-flow/memory/dist/database-provider.test.js

@@ -1,285 +0,0 @@
-/**
- * Database Provider Tests - Cross-Platform Compatibility
- *
- * Tests for platform-aware database selection and fallback mechanisms
- */
-import { describe, it, expect, afterEach } from 'vitest';
-import { createDatabase, getPlatformInfo, getAvailableProviders } from './database-provider.js';
-import { createDefaultEntry } from './types.js';
-import { unlinkSync, existsSync } from 'node:fs';
-describe('DatabaseProvider', () => {
-    const testDbPath = './test-database-provider.db';
-    afterEach(() => {
-        // Cleanup test database
-        if (existsSync(testDbPath)) {
-            try {
-                unlinkSync(testDbPath);
-            }
-            catch (error) {
-                // Ignore cleanup errors
-            }
-        }
-    });
-    describe('Platform Detection', () => {
-        it('should detect platform information', () => {
-            const info = getPlatformInfo();
-            expect(info).toHaveProperty('os');
-            expect(info).toHaveProperty('isWindows');
-            expect(info).toHaveProperty('isMacOS');
-            expect(info).toHaveProperty('isLinux');
-            expect(info).toHaveProperty('recommendedProvider');
-            // Should recommend sql.js on Windows, better-sqlite3 on Unix
-            if (info.isWindows) {
-                expect(info.recommendedProvider).toBe('sql.js');
-            }
-            else {
-                expect(info.recommendedProvider).toBe('sql.js');
-            }
-        });
-    });
-    describe('Provider Availability', () => {
-        it('should check available providers', async () => {
-            const available = await getAvailableProviders();
-            expect(available).toHaveProperty('betterSqlite3');
-            expect(available).toHaveProperty('sqlJs');
-            expect(available).toHaveProperty('json');
-            // JSON backend should always be available
-            expect(available.json).toBe(true);
-        });
-    });
-    describe('Automatic Provider Selection', () => {
-        it('should create database with auto provider selection', async () => {
-            const db = await createDatabase(':memory:');
-            expect(db).toBeDefined();
-            await expect(db.count()).resolves.toBe(0);
-            await db.shutdown();
-        });
-        it('should create persistent database with auto provider', async () => {
-            const db = await createDatabase(testDbPath);
-            expect(db).toBeDefined();
-            // Store test entry
-            const entry = createDefaultEntry({
-                key: 'test-key',
-                content: 'test content',
-                namespace: 'test',
-            });
-            await db.store(entry);
-            await expect(db.count()).resolves.toBe(1);
-            await db.shutdown();
-        });
-    });
-    describe('Explicit Provider Selection', () => {
-        it('should create database with sql.js provider', async () => {
-            const available = await getAvailableProviders();
-            if (!available.sqlJs) {
-                console.log('sql.js not available, skipping test');
-                return;
-            }
-            const db = await createDatabase(':memory:', {
-                provider: 'sql.js',
-                verbose: false,
-            });
-            expect(db).toBeDefined();
-            // Test basic operations
-            const entry = createDefaultEntry({
-                key: 'sqljs-test',
-                content: 'testing sql.js backend',
-                namespace: 'test',
-            });
-            await db.store(entry);
-            await expect(db.count()).resolves.toBe(1);
-            const retrieved = await db.get(entry.id);
-            expect(retrieved).toBeDefined();
-            expect(retrieved?.key).toBe('sqljs-test');
-            await db.shutdown();
-        });
-        it('should create database with better-sqlite3 provider', async () => {
-            const available = await getAvailableProviders();
-            if (!available.betterSqlite3) {
-                console.log('better-sqlite3 not available, skipping test');
-                return;
-            }
-            const db = await createDatabase(':memory:', {
-                provider: 'sql.js',
-                verbose: false,
-            });
-            expect(db).toBeDefined();
-            // Test basic operations
-            const entry = createDefaultEntry({
-                key: 'sqlite-test',
-                content: 'testing better-sqlite3 backend',
-                namespace: 'test',
-            });
-            await db.store(entry);
-            await expect(db.count()).resolves.toBe(1);
-            const retrieved = await db.get(entry.id);
-            expect(retrieved).toBeDefined();
-            expect(retrieved?.key).toBe('sqlite-test');
-            await db.shutdown();
-        });
-        it('should create database with JSON provider', async () => {
-            const db = await createDatabase(testDbPath, {
-                provider: 'json',
-                verbose: false,
-            });
-            expect(db).toBeDefined();
-            // Test basic operations
-            const entry = createDefaultEntry({
-                key: 'json-test',
-                content: 'testing JSON backend',
-                namespace: 'test',
-            });
-            await db.store(entry);
-            await expect(db.count()).resolves.toBe(1);
-            const retrieved = await db.get(entry.id);
-            expect(retrieved).toBeDefined();
-            expect(retrieved?.key).toBe('json-test');
-            await db.shutdown();
-        });
-    });
-    describe('Cross-Platform Functionality', () => {
-        it('should handle CRUD operations consistently across providers', async () => {
-            const available = await getAvailableProviders();
-            const providers = [];
-            if (available.betterSqlite3)
-                providers.push('sql.js');
-            if (available.sqlJs)
-                providers.push('sql.js');
-            providers.push('json'); // Always available
-            for (const provider of providers) {
-                const db = await createDatabase(':memory:', { provider });
-                // Create
-                const entry = createDefaultEntry({
-                    key: `test-${provider}`,
-                    content: `testing ${provider}`,
-                    namespace: 'cross-platform',
-                    tags: ['test', provider],
-                });
-                await db.store(entry);
-                // Read
-                const retrieved = await db.get(entry.id);
-                expect(retrieved).toBeDefined();
-                expect(retrieved?.key).toBe(`test-${provider}`);
-                expect(retrieved?.tags).toContain(provider);
-                // Update
-                const updated = await db.update(entry.id, {
-                    content: `updated ${provider}`,
-                });
-                expect(updated).toBeDefined();
-                expect(updated?.content).toBe(`updated ${provider}`);
-                // Query
-                const results = await db.query({
-                    type: 'hybrid',
-                    namespace: 'cross-platform',
-                    limit: 10,
-                });
-                expect(results.length).toBe(1);
-                expect(results[0].key).toBe(`test-${provider}`);
-                // Delete
-                const deleted = await db.delete(entry.id);
-                expect(deleted).toBe(true);
-                await expect(db.count()).resolves.toBe(0);
-                await db.shutdown();
-            }
-        });
-        it('should handle namespace operations across providers', async () => {
-            const db = await createDatabase(':memory:');
-            // Create entries in different namespaces
-            const entries = [
-                createDefaultEntry({ key: 'entry1', content: 'content1', namespace: 'ns1' }),
-                createDefaultEntry({ key: 'entry2', content: 'content2', namespace: 'ns1' }),
-                createDefaultEntry({ key: 'entry3', content: 'content3', namespace: 'ns2' }),
-            ];
-            for (const entry of entries) {
-                await db.store(entry);
-            }
-            // List namespaces
-            const namespaces = await db.listNamespaces();
-            expect(namespaces).toContain('ns1');
-            expect(namespaces).toContain('ns2');
-            // Count by namespace
-            await expect(db.count('ns1')).resolves.toBe(2);
-            await expect(db.count('ns2')).resolves.toBe(1);
-            // Clear namespace
-            const cleared = await db.clearNamespace('ns1');
-            expect(cleared).toBe(2);
-            await expect(db.count('ns1')).resolves.toBe(0);
-            await expect(db.count('ns2')).resolves.toBe(1);
-            await db.shutdown();
-        });
-        it('should handle bulk operations across providers', async () => {
-            const db = await createDatabase(':memory:');
-            // Bulk insert
-            const entries = Array.from({ length: 10 }, (_, i) => createDefaultEntry({
-                key: `bulk-${i}`,
-                content: `content ${i}`,
-                namespace: 'bulk-test',
-            }));
-            await db.bulkInsert(entries);
-            await expect(db.count('bulk-test')).resolves.toBe(10);
-            // Bulk delete
-            const idsToDelete = entries.slice(0, 5).map((e) => e.id);
-            const deletedCount = await db.bulkDelete(idsToDelete);
-            expect(deletedCount).toBe(5);
-            await expect(db.count('bulk-test')).resolves.toBe(5);
-            await db.shutdown();
-        });
-    });
-    describe('Health Check', () => {
-        it('should perform health check', async () => {
-            const db = await createDatabase(':memory:');
-            const health = await db.healthCheck();
-            expect(health).toHaveProperty('status');
-            expect(health).toHaveProperty('components');
-            expect(health).toHaveProperty('timestamp');
-            expect(health).toHaveProperty('issues');
-            expect(health).toHaveProperty('recommendations');
-            expect(health.components).toHaveProperty('storage');
-            expect(health.components).toHaveProperty('index');
-            expect(health.components).toHaveProperty('cache');
-            await db.shutdown();
-        });
-    });
-    describe('Statistics', () => {
-        it('should provide backend statistics', async () => {
-            const db = await createDatabase(':memory:');
-            // Add some test data
-            const entries = [
-                createDefaultEntry({ key: 'stat1', content: 'content1', namespace: 'stats', type: 'semantic' }),
-                createDefaultEntry({ key: 'stat2', content: 'content2', namespace: 'stats', type: 'episodic' }),
-                createDefaultEntry({ key: 'stat3', content: 'content3', namespace: 'stats', type: 'semantic' }),
-            ];
-            for (const entry of entries) {
-                await db.store(entry);
-            }
-            const stats = await db.getStats();
-            expect(stats).toHaveProperty('totalEntries');
-            expect(stats).toHaveProperty('entriesByNamespace');
-            expect(stats).toHaveProperty('entriesByType');
-            expect(stats).toHaveProperty('memoryUsage');
-            expect(stats).toHaveProperty('avgQueryTime');
-            expect(stats.totalEntries).toBe(3);
-            await db.shutdown();
-        });
-    });
-    describe('Error Handling', () => {
-        it('should handle missing entries gracefully', async () => {
-            const db = await createDatabase(':memory:');
-            const entry = await db.get('non-existent-id');
-            expect(entry).toBeNull();
-            const byKey = await db.getByKey('non-existent-ns', 'non-existent-key');
-            expect(byKey).toBeNull();
-            await db.shutdown();
-        });
-        it('should handle empty queries', async () => {
-            const db = await createDatabase(':memory:');
-            const results = await db.query({
-                type: 'hybrid',
-                limit: 10,
-            });
-            expect(results).toEqual([]);
-            await db.shutdown();
-        });
-    });
-});
-//# sourceMappingURL=database-provider.test.js.map

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/entities/memory-entry.js

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

@@ -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/index.js

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