moflo 4.8.16 → 4.8.19

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/agentdb-backend.test.js

@@ -1,258 +0,0 @@
-/**
- * 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/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/delete-memory.command.js

@@ -1,129 +0,0 @@
-/**
- * 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/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/commands/store-memory.command.js

@@ -1,72 +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 } 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/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/index.js

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