moflo 4.0.2 → 4.0.3

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

@@ -0,0 +1,7 @@
+/**
+ * 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/v3/@claude-flow/memory/dist/agentdb-backend.test.js

@@ -0,0 +1,258 @@
+/**
+ * AgentDB Backend Tests
+ *
+ * Tests for agentdb@2.0.0-alpha.3.4 integration with V3 memory system
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AgentDBBackend } from './agentdb-backend.js';
+import { createDefaultEntry } from './types.js';
+describe('AgentDBBackend', () => {
+    let backend;
+    beforeEach(async () => {
+        backend = new AgentDBBackend({
+            dbPath: ':memory:',
+            namespace: 'test',
+            vectorDimension: 384,
+        });
+        await backend.initialize();
+    });
+    afterEach(async () => {
+        await backend.shutdown();
+    });
+    describe('Initialization', () => {
+        it('should initialize successfully', async () => {
+            expect(backend).toBeDefined();
+        });
+        it('should handle missing agentdb gracefully', async () => {
+            const fallbackBackend = new AgentDBBackend();
+            await fallbackBackend.initialize();
+            // Should still work with in-memory fallback
+            expect(fallbackBackend).toBeDefined();
+            await fallbackBackend.shutdown();
+        });
+    });
+    describe('Basic CRUD Operations', () => {
+        it('should store and retrieve entries', async () => {
+            const entry = createDefaultEntry({
+                key: 'test-key',
+                content: 'Test content',
+                type: 'episodic',
+            });
+            await backend.store(entry);
+            const retrieved = await backend.get(entry.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.content).toBe('Test content');
+        });
+        it('should get entry by key', async () => {
+            const entry = createDefaultEntry({
+                key: 'unique-key',
+                content: 'Unique content',
+                namespace: 'test',
+            });
+            await backend.store(entry);
+            const retrieved = await backend.getByKey('test', 'unique-key');
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.content).toBe('Unique content');
+        });
+        it('should update entries', async () => {
+            const entry = createDefaultEntry({
+                key: 'update-test',
+                content: 'Original content',
+            });
+            await backend.store(entry);
+            const originalVersion = entry.version;
+            const updated = await backend.update(entry.id, {
+                content: 'Updated content',
+            });
+            expect(updated?.content).toBe('Updated content');
+            expect(updated?.version).toBe(originalVersion + 1);
+        });
+        it('should delete entries', async () => {
+            const entry = createDefaultEntry({
+                key: 'delete-test',
+                content: 'To be deleted',
+            });
+            await backend.store(entry);
+            const deleted = await backend.delete(entry.id);
+            expect(deleted).toBe(true);
+            const retrieved = await backend.get(entry.id);
+            expect(retrieved).toBeNull();
+        });
+    });
+    describe('Query Operations', () => {
+        beforeEach(async () => {
+            // Insert test data
+            await backend.store(createDefaultEntry({
+                key: 'entry-1',
+                content: 'First entry',
+                namespace: 'test',
+                tags: ['tag1', 'tag2'],
+            }));
+            await backend.store(createDefaultEntry({
+                key: 'entry-2',
+                content: 'Second entry',
+                namespace: 'test',
+                tags: ['tag2', 'tag3'],
+            }));
+            await backend.store(createDefaultEntry({
+                key: 'entry-3',
+                content: 'Third entry',
+                namespace: 'other',
+                tags: ['tag1'],
+            }));
+        });
+        it('should query by namespace', async () => {
+            const results = await backend.query({
+                type: 'hybrid',
+                namespace: 'test',
+                limit: 10,
+            });
+            expect(results.length).toBe(2);
+        });
+        it('should query by exact key', async () => {
+            const results = await backend.query({
+                type: 'exact',
+                namespace: 'test',
+                key: 'entry-1',
+                limit: 10,
+            });
+            expect(results.length).toBe(1);
+            expect(results[0].content).toBe('First entry');
+        });
+        it('should query by prefix', async () => {
+            const results = await backend.query({
+                type: 'prefix',
+                keyPrefix: 'entry-',
+                limit: 10,
+            });
+            expect(results.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should query by tags', async () => {
+            const results = await backend.query({
+                type: 'tag',
+                tags: ['tag2'],
+                limit: 10,
+            });
+            expect(results.length).toBe(2);
+        });
+    });
+    describe('Vector Search', () => {
+        it('should perform brute-force search when agentdb unavailable', async () => {
+            const entry = createDefaultEntry({
+                key: 'vector-test',
+                content: 'Vector content',
+            });
+            // Create a fake embedding
+            entry.embedding = new Float32Array([0.1, 0.2, 0.3, 0.4]);
+            await backend.store(entry);
+            const queryEmbedding = new Float32Array([0.1, 0.2, 0.3, 0.4]);
+            const results = await backend.search(queryEmbedding, { k: 5 });
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].entry.id).toBe(entry.id);
+        });
+        it('should handle semantic queries', async () => {
+            const entry = createDefaultEntry({
+                key: 'semantic-test',
+                content: 'Semantic content',
+            });
+            entry.embedding = new Float32Array([0.5, 0.5, 0.5, 0.5]);
+            await backend.store(entry);
+            const results = await backend.query({
+                type: 'semantic',
+                embedding: new Float32Array([0.5, 0.5, 0.5, 0.5]),
+                limit: 5,
+            });
+            expect(results.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Bulk Operations', () => {
+        it('should bulk insert entries', async () => {
+            const entries = [
+                createDefaultEntry({ key: 'bulk-1', content: 'Bulk 1' }),
+                createDefaultEntry({ key: 'bulk-2', content: 'Bulk 2' }),
+                createDefaultEntry({ key: 'bulk-3', content: 'Bulk 3' }),
+            ];
+            await backend.bulkInsert(entries);
+            const count = await backend.count();
+            expect(count).toBeGreaterThanOrEqual(3);
+        });
+        it('should bulk delete entries', async () => {
+            const entries = [
+                createDefaultEntry({ key: 'delete-1', content: 'Delete 1' }),
+                createDefaultEntry({ key: 'delete-2', content: 'Delete 2' }),
+            ];
+            await backend.bulkInsert(entries);
+            const ids = entries.map((e) => e.id);
+            const deleted = await backend.bulkDelete(ids);
+            expect(deleted).toBe(2);
+        });
+    });
+    describe('Statistics and Health', () => {
+        it('should provide backend statistics', async () => {
+            await backend.store(createDefaultEntry({ key: 'stats-test', content: 'Stats content' }));
+            const stats = await backend.getStats();
+            expect(stats.totalEntries).toBeGreaterThan(0);
+            expect(stats.avgQueryTime).toBeGreaterThanOrEqual(0);
+            expect(stats.memoryUsage).toBeGreaterThan(0);
+        });
+        it('should perform health checks', async () => {
+            const health = await backend.healthCheck();
+            expect(health.status).toBeDefined();
+            expect(['healthy', 'degraded', 'unhealthy']).toContain(health.status);
+            expect(health.components).toBeDefined();
+            expect(health.components.storage).toBeDefined();
+            expect(health.components.index).toBeDefined();
+            expect(health.components.cache).toBeDefined();
+        });
+    });
+    describe('Namespace Operations', () => {
+        beforeEach(async () => {
+            await backend.store(createDefaultEntry({
+                key: 'ns1-entry',
+                content: 'NS1',
+                namespace: 'namespace1',
+            }));
+            await backend.store(createDefaultEntry({
+                key: 'ns2-entry',
+                content: 'NS2',
+                namespace: 'namespace2',
+            }));
+        });
+        it('should list namespaces', async () => {
+            const namespaces = await backend.listNamespaces();
+            expect(namespaces).toContain('namespace1');
+            expect(namespaces).toContain('namespace2');
+        });
+        it('should count entries by namespace', async () => {
+            const count = await backend.count('namespace1');
+            expect(count).toBe(1);
+        });
+        it('should clear namespace', async () => {
+            const cleared = await backend.clearNamespace('namespace1');
+            expect(cleared).toBe(1);
+            const count = await backend.count('namespace1');
+            expect(count).toBe(0);
+        });
+    });
+    describe('Graceful Degradation', () => {
+        it('should work without agentdb package', async () => {
+            const fallbackBackend = new AgentDBBackend({
+                dbPath: ':memory:',
+            });
+            await fallbackBackend.initialize();
+            const entry = createDefaultEntry({
+                key: 'fallback-test',
+                content: 'Fallback content',
+            });
+            await fallbackBackend.store(entry);
+            const retrieved = await fallbackBackend.get(entry.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.content).toBe('Fallback content');
+            await fallbackBackend.shutdown();
+        });
+        it('should indicate availability status', () => {
+            expect(typeof backend.isAvailable()).toBe('boolean');
+        });
+    });
+});
+//# sourceMappingURL=agentdb-backend.test.js.map

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

@@ -0,0 +1,65 @@
+/**
+ * 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/v3/@claude-flow/memory/dist/application/commands/delete-memory.command.js

@@ -0,0 +1,129 @@
+/**
+ * Delete Memory Command - Application Layer (CQRS)
+ *
+ * Command for deleting memory entries.
+ * Supports soft delete and hard delete.
+ *
+ * @module v3/memory/application/commands
+ */
+/**
+ * Delete Memory Command Handler
+ */
+export class DeleteMemoryCommandHandler {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async execute(input) {
+        let entryId;
+        // Find entry by ID or by namespace:key
+        if (input.id) {
+            entryId = input.id;
+        }
+        else if (input.namespace && input.key) {
+            const entry = await this.repository.findByKey(input.namespace, input.key);
+            entryId = entry?.id;
+        }
+        if (!entryId) {
+            return {
+                success: false,
+                deleted: false,
+                wasHardDelete: false,
+            };
+        }
+        if (input.hardDelete) {
+            // Hard delete - remove from database
+            const deleted = await this.repository.delete(entryId);
+            return {
+                success: true,
+                deleted,
+                entryId,
+                wasHardDelete: true,
+            };
+        }
+        else {
+            // Soft delete - mark as deleted
+            const entry = await this.repository.findById(entryId);
+            if (entry) {
+                entry.delete();
+                await this.repository.save(entry);
+                return {
+                    success: true,
+                    deleted: true,
+                    entryId,
+                    wasHardDelete: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            deleted: false,
+            entryId,
+            wasHardDelete: false,
+        };
+    }
+}
+/**
+ * Bulk Delete Memory Command Handler
+ */
+export class BulkDeleteMemoryCommandHandler {
+    repository;
+    constructor(repository) {
+        this.repository = repository;
+    }
+    async execute(input) {
+        let idsToDelete = [];
+        if (input.ids) {
+            idsToDelete = input.ids;
+        }
+        else if (input.namespace) {
+            const entries = await this.repository.findByNamespace(input.namespace);
+            idsToDelete = entries
+                .filter((e) => !input.olderThan || e.createdAt < input.olderThan)
+                .map((e) => e.id);
+        }
+        if (idsToDelete.length === 0) {
+            return {
+                success: true,
+                deletedCount: 0,
+                failedCount: 0,
+                errors: [],
+            };
+        }
+        if (input.hardDelete) {
+            const result = await this.repository.deleteMany(idsToDelete);
+            return {
+                success: result.failed === 0,
+                deletedCount: result.success,
+                failedCount: result.failed,
+                errors: result.errors,
+            };
+        }
+        else {
+            // Soft delete
+            const entries = await this.repository.findByIds(idsToDelete);
+            let deletedCount = 0;
+            const errors = [];
+            for (const entry of entries) {
+                try {
+                    entry.delete();
+                    await this.repository.save(entry);
+                    deletedCount++;
+                }
+                catch (error) {
+                    errors.push({
+                        id: entry.id,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            return {
+                success: errors.length === 0,
+                deletedCount,
+                failedCount: errors.length,
+                errors,
+            };
+        }
+    }
+}
+//# sourceMappingURL=delete-memory.command.js.map

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

@@ -0,0 +1,48 @@
+/**
+ * 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/v3/@claude-flow/memory/dist/application/commands/store-memory.command.js

@@ -0,0 +1,72 @@
+/**
+ * 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 } from '../../domain/entities/memory-entry.js';
+/**
+ * Store Memory Command Handler
+ *
+ * Handles the command to store a memory entry.
+ * Coordinates between domain services and repository.
+ */
+export class StoreMemoryCommandHandler {
+    repository;
+    domainService;
+    constructor(repository, domainService) {
+        this.repository = repository;
+        this.domainService = domainService;
+    }
+    /**
+     * Execute the store memory command
+     */
+    async execute(input) {
+        // Check if entry already exists
+        const existing = await this.repository.findByKey(input.namespace, input.key);
+        const isUpdate = existing !== null;
+        let entry;
+        if (existing) {
+            // Update existing entry
+            existing.updateValue(input.value);
+            if (input.vector) {
+                existing.updateVector(input.vector);
+            }
+            if (input.metadata) {
+                for (const [key, value] of Object.entries(input.metadata)) {
+                    existing.setMetadata(key, value);
+                }
+            }
+            await this.repository.save(existing);
+            entry = existing;
+        }
+        else {
+            // Create new entry
+            if (input.type) {
+                entry = MemoryEntry.create({
+                    namespace: input.namespace,
+                    key: input.key,
+                    value: input.value,
+                    type: input.type,
+                    vector: input.vector,
+                    metadata: input.metadata,
+                    ttl: input.ttl,
+                });
+                await this.repository.save(entry);
+            }
+            else {
+                // Use domain service for type detection
+                entry = await this.domainService.storeWithTypeDetection(input.namespace, input.key, input.value, input.vector);
+            }
+        }
+        return {
+            success: true,
+            entryId: entry.id,
+            entry,
+            isUpdate,
+        };
+    }
+}
+//# sourceMappingURL=store-memory.command.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * 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/v3/@claude-flow/memory/dist/application/index.js

@@ -0,0 +1,15 @@
+/**
+ * Memory Application Layer - Public Exports
+ *
+ * Exports all application services, commands, and queries.
+ *
+ * @module v3/memory/application
+ */
+// Commands
+export { StoreMemoryCommandHandler, } from './commands/store-memory.command.js';
+export { DeleteMemoryCommandHandler, BulkDeleteMemoryCommandHandler, } from './commands/delete-memory.command.js';
+// Queries
+export { SearchMemoryQueryHandler, GetMemoryByKeyQueryHandler, } from './queries/search-memory.query.js';
+// Application Service
+export { MemoryApplicationService } from './services/memory-application-service.js';
+//# sourceMappingURL=index.js.map

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

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