🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
checkpoint: File edit:
rUv6aae801e5dee
diff --git a/v3/@claude-flow/memory/src/hybrid-backend.test.ts b/v3/@claude-flow/memory/src/hybrid-backend.test.tsnew file mode 100644index 0000000000..55a2b34dc5--- /dev/null+++ b/v3/@claude-flow/memory/src/hybrid-backend.test.ts@@ -0,0 +1,396 @@+/**+ * Tests for HybridBackend (ADR-009)+ *+ * Verifies that the hybrid backend correctly routes queries between+ * SQLite (structured) and AgentDB (semantic) backends.+ */++import { describe, it, expect, beforeEach, afterEach } from 'vitest';+import { HybridBackend } from './hybrid-backend.js';+import { MemoryEntry, createDefaultEntry } from './types.js';++describe('HybridBackend - ADR-009', () => {+ let backend: HybridBackend;++ // Mock embedding generator for testing+ const mockEmbedding = async (text: string): Promise<Float32Array> => {+ // Simple mock: convert text to numbers+ const arr = new Float32Array(128);+ for (let i = 0; i < Math.min(text.length, 128); i++) {+ arr[i] = text.charCodeAt(i) / 255;+ }+ return arr;+ };++ beforeEach(async () => {+ backend = new HybridBackend({+ sqlite: {+ databasePath: ':memory:', // In-memory for testing+ verbose: false,+ },+ agentdb: {+ dimensions: 128,+ cacheEnabled: true,+ },+ embeddingGenerator: mockEmbedding,+ dualWrite: true,+ });++ await backend.initialize();+ });++ afterEach(async () => {+ await backend.shutdown();+ });++ describe('Initialization', () => {+ it('should initialize both backends', async () => {+ const health = await backend.healthCheck();+ expect(health.status).toBe('healthy');+ expect(health.components.sqlite).toBeDefined();+ expect(health.components.agentdb).toBeDefined();+ });+ });++ describe('Store Operations', () => {+ it('should store entries in both backends (dual-write)', async () => {+ const entry = createDefaultEntry({+ key: 'test-key',+ content: 'Test content for dual write',+ namespace: 'test',+ });++ await backend.store(entry);++ // Verify in SQLite+ const fromSQLite = await backend.getSQLiteBackend().get(entry.id);+ expect(fromSQLite).toBeDefined();+ expect(fromSQLite?.key).toBe('test-key');++ // Verify in AgentDB+ const fromAgentDB = await backend.getAgentDBBackend().get(entry.id);+ expect(fromAgentDB).toBeDefined();+ expect(fromAgentDB?.key).toBe('test-key');+ });++ it('should handle bulk inserts', async () => {+ const entries = Array.from({ length: 10 }, (_, i) =>+ createDefaultEntry({+ key: `bulk-${i}`,+ content: `Bulk content ${i}`,+ namespace: 'bulk-test',+ })+ );++ await backend.bulkInsert(entries);++ const count = await backend.count('bulk-test');+ expect(count).toBe(10);+ });+ });++ describe('Exact Match Queries (SQLite)', () => {+ beforeEach(async () => {+ // Insert test data+ await backend.store(+ createDefaultEntry({+ key: 'user-123',+ content: 'User data for testing',+ namespace: 'users',+ })+ );+ });++ it('should route exact key queries to SQLite', async () => {+ const result = await backend.getByKey('users', 'user-123');+ expect(result).toBeDefined();+ expect(result?.key).toBe('user-123');+ });++ it('should handle prefix queries via SQLite', async () => {+ await backend.store(+ createDefaultEntry({+ key: 'user-456',+ content: 'Another user',+ namespace: 'users',+ })+ );++ const results = await backend.queryStructured({+ namespace: 'users',+ keyPrefix: 'user-',+ limit: 10,+ });++ expect(results.length).toBeGreaterThanOrEqual(2);+ expect(results.every((r) => r.key.startsWith('user-'))).toBe(true);+ });+ });++ describe('Semantic Search (AgentDB)', () => {+ beforeEach(async () => {+ // Insert test data with semantic content+ await backend.store(+ createDefaultEntry({+ key: 'doc-1',+ content: 'Authentication and authorization patterns',+ namespace: 'docs',+ tags: ['security', 'auth'],+ })+ );++ await backend.store(+ createDefaultEntry({+ key: 'doc-2',+ content: 'Database optimization techniques',+ namespace: 'docs',+ tags: ['performance', 'database'],+ })+ );++ await backend.store(+ createDefaultEntry({+ key: 'doc-3',+ content: 'Secure authentication methods',+ namespace: 'docs',+ tags: ['security', 'auth'],+ })+ );+ });++ it('should perform semantic search via AgentDB', async () => {+ const results = await backend.querySemantic({+ content: 'authentication security',+ k: 5,+ threshold: 0.1, // Low threshold for simple mock embeddings+ });++ expect(results.length).toBeGreaterThan(0);+ // Should find docs about authentication+ const hasAuthDoc = results.some((r) => r.content.includes('Authentication'));+ expect(hasAuthDoc).toBe(true);+ });++ it('should support semantic search with filters', async () => {+ const results = await backend.querySemantic({+ content: 'security patterns',+ k: 10,+ filters: {+ type: 'semantic',+ tags: ['security'],+ limit: 10,+ },+ });++ expect(results.every((r) => r.tags.includes('security'))).toBe(true);+ });+ });++ describe('Hybrid Queries', () => {+ beforeEach(async () => {+ // Insert diverse test data+ for (let i = 0; i < 5; i++) {+ await backend.store(+ createDefaultEntry({+ key: `hybrid-${i}`,+ content: `Content about ${i % 2 === 0 ? 'authentication' : 'database'} topic ${i}`,+ namespace: 'hybrid-test',+ tags: i % 2 === 0 ? ['auth'] : ['db'],+ })+ );+ }+ });++ it('should combine semantic and structured queries (union)', async () => {+ const results = await backend.queryHybrid({+ semantic: {+ content: 'authentication',+ k: 3,+ },+ structured: {+ namespace: 'hybrid-test',+ keyPrefix: 'hybrid-',+ limit: 5,+ },+ combineStrategy: 'union',+ });++ expect(results.length).toBeGreaterThan(0);+ expect(results.every((r) => r.namespace === 'hybrid-test')).toBe(true);+ });++ it('should support semantic-first strategy', async () => {+ const results = await backend.queryHybrid({+ semantic: {+ content: 'database',+ k: 2,+ },+ structured: {+ namespace: 'hybrid-test',+ limit: 3,+ },+ combineStrategy: 'semantic-first',+ });++ expect(results.length).toBeGreaterThan(0);+ // First results should be from semantic search+ });+ });++ describe('CRUD Operations', () => {+ let testEntry: MemoryEntry;++ beforeEach(async () => {+ testEntry = createDefaultEntry({+ key: 'crud-test',+ content: 'Original content',+ namespace: 'test',+ });+ await backend.store(testEntry);+ });++ it('should update entries in both backends', async () => {+ const updated = await backend.update(testEntry.id, {+ content: 'Updated content',+ tags: ['updated'],+ });++ expect(updated).toBeDefined();+ expect(updated?.content).toBe('Updated content');+ expect(updated?.tags).toContain('updated');++ // Verify in SQLite+ const fromSQLite = await backend.getSQLiteBackend().get(testEntry.id);+ expect(fromSQLite?.content).toBe('Updated content');++ // Verify in AgentDB+ const fromAgentDB = await backend.getAgentDBBackend().get(testEntry.id);+ expect(fromAgentDB?.content).toBe('Updated content');+ });++ it('should delete entries from both backends', async () => {+ const deleted = await backend.delete(testEntry.id);+ expect(deleted).toBe(true);++ const fromSQLite = await backend.getSQLiteBackend().get(testEntry.id);+ expect(fromSQLite).toBeNull();++ const fromAgentDB = await backend.getAgentDBBackend().get(testEntry.id);+ expect(fromAgentDB).toBeNull();+ });+ });++ describe('Namespace Operations', () => {+ beforeEach(async () => {+ await backend.store(+ createDefaultEntry({+ key: 'ns1-key',+ content: 'Namespace 1 content',+ namespace: 'ns1',+ })+ );+ await backend.store(+ createDefaultEntry({+ key: 'ns2-key',+ content: 'Namespace 2 content',+ namespace: 'ns2',+ })+ );+ });++ it('should list all namespaces', async () => {+ const namespaces = await backend.listNamespaces();+ expect(namespaces).toContain('ns1');+ expect(namespaces).toContain('ns2');+ });++ it('should count entries per namespace', async () => {+ const ns1Count = await backend.count('ns1');+ const ns2Count = await backend.count('ns2');++ expect(ns1Count).toBe(1);+ expect(ns2Count).toBe(1);+ });++ it('should clear namespace in both backends', async () => {+ const deleted = await backend.clearNamespace('ns1');+ expect(deleted).toBe(1);++ const ns1Count = await backend.count('ns1');+ expect(ns1Count).toBe(0);++ const ns2Count = await backend.count('ns2');+ expect(ns2Count).toBe(1);+ });+ });++ describe('Statistics', () => {+ it('should provide combined statistics', async () => {+ // Add some test data+ for (let i = 0; i < 5; i++) {+ await backend.store(+ createDefaultEntry({+ key: `stats-${i}`,+ content: `Stats content ${i}`,+ namespace: 'stats',+ })+ );+ }++ const stats = await backend.getStats();+ expect(stats.totalEntries).toBeGreaterThanOrEqual(5);+ expect(stats.entriesByNamespace['stats']).toBe(5);+ expect(stats.routingStats).toBeDefined();+ });+ });++ describe('Health Check', () => {+ it('should report healthy status for both backends', async () => {+ const health = await backend.healthCheck();+ expect(health.status).toBe('healthy');+ expect(health.components.sqlite?.status).toBe('healthy');+ expect(health.components.agentdb?.status).toBe('healthy');+ });+ });++ describe('Query Routing', () => {+ it('should auto-route semantic queries to AgentDB', async () => {+ await backend.store(+ createDefaultEntry({+ key: 'route-test',+ content: 'Routing test content',+ namespace: 'routing',+ })+ );++ const results = await backend.query({+ type: 'semantic',+ content: 'routing test',+ limit: 5,+ });++ const stats = await backend.getStats();+ expect(stats.routingStats.agentdbQueries).toBeGreaterThan(0);+ });++ it('should auto-route exact queries to SQLite', async () => {+ await backend.store(+ createDefaultEntry({+ key: 'exact-test',+ content: 'Exact match test',+ namespace: 'routing',+ })+ );++ const results = await backend.query({+ type: 'exact',+ key: 'exact-test',+ namespace: 'routing',+ limit: 1,+ });++ const stats = await backend.getStats();+ expect(stats.routingStats.sqliteQueries).toBeGreaterThan(0);+ });+ });+});diff --git a/v3/@claude-flow/shared/src/plugin-loader.ts b/v3/@claude-flow/shared/src/plugin-loader.tsindex a87356ae8c..d2ea5bf6c7 100644--- a/v3/@claude-flow/shared/src/plugin-loader.ts+++ b/v3/@claude-flow/shared/src/plugin-loader.ts@@ -487,7 +487,7 @@ export class PluginLoader {if (!node) return 0;let maxDepth = 0;- for (const dep of node.dependencies) {+ for (const dep of Array.from(node.dependencies)) {maxDepth = Math.max(maxDepth, visit(dep) + 1);}@@ -495,7 +495,7 @@ export class PluginLoader {return maxDepth;};- for (const name of graph.keys()) {+ for (const name of Array.from(graph.keys())) {visit(name);}}