Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

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.ts
new file mode 100644
index 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.ts
index 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);
}
}