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 edits

rUv9de737571047
diff --git a/v3/@claude-flow/memory/src/learning-bridge.test.ts b/v3/@claude-flow/memory/src/learning-bridge.test.ts
new file mode 100644
index 0000000000..86a8be5728
--- /dev/null
+++ b/v3/@claude-flow/memory/src/learning-bridge.test.ts
@@ -0,0 +1,841 @@
+/**
+ * Tests for LearningBridge
+ *
+ * TDD London School (mock-first) tests for the bridge that connects
+ * AutoMemoryBridge insights to the NeuralLearningSystem.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type { IMemoryBackend, MemoryEntry, MemoryEntryUpdate } from './types.js';
+import type { MemoryInsight } from './auto-memory-bridge.js';
+
+// ===== Mock Neural System =====
+
+const mockNeuralSystem = {
+ initialize: vi.fn().mockResolvedValue(undefined),
+ beginTask: vi.fn().mockReturnValue('traj-1'),
+ recordStep: vi.fn(),
+ completeTask: vi.fn().mockResolvedValue(undefined),
+ findPatterns: vi.fn().mockResolvedValue([]),
+ cleanup: vi.fn().mockResolvedValue(undefined),
+};
+
+// Control whether the dynamic import succeeds
+let neuralImportShouldFail = false;
+
+vi.mock('@claude-flow/neural', () => {
+ if (neuralImportShouldFail) {
+ throw new Error('Module not found: @claude-flow/neural');
+ }
+ return {
+ NeuralLearningSystem: vi.fn().mockImplementation(() => mockNeuralSystem),
+ };
+});
+
+// Import AFTER mocking so the dynamic import inside the class picks up the mock
+import { LearningBridge } from './learning-bridge.js';
+import type {
+ LearningBridgeConfig,
+ LearningStats,
+ ConsolidateResult,
+ PatternMatch,
+} from './learning-bridge.js';
+
+// ===== Mock Backend =====
+
+function createMockBackend(): IMemoryBackend & { storedEntries: MemoryEntry[] } {
+ const storedEntries: MemoryEntry[] = [];
+
+ return {
+ storedEntries,
+ initialize: vi.fn().mockResolvedValue(undefined),
+ shutdown: vi.fn().mockResolvedValue(undefined),
+ store: vi.fn().mockImplementation(async (entry: MemoryEntry) => {
+ storedEntries.push(entry);
+ }),
+ get: vi.fn().mockResolvedValue(null),
+ getByKey: vi.fn().mockResolvedValue(null),
+ update: vi.fn().mockImplementation(async (id: string, update: MemoryEntryUpdate) => {
+ const entry = storedEntries.find(e => e.id === id);
+ if (!entry) return null;
+ if (update.metadata) entry.metadata = { ...entry.metadata, ...update.metadata };
+ return entry;
+ }),
+ delete: vi.fn().mockResolvedValue(true),
+ query: vi.fn().mockResolvedValue([]),
+ search: vi.fn().mockResolvedValue([]),
+ bulkInsert: vi.fn().mockResolvedValue(undefined),
+ bulkDelete: vi.fn().mockResolvedValue(0),
+ count: vi.fn().mockResolvedValue(0),
+ listNamespaces: vi.fn().mockResolvedValue([]),
+ clearNamespace: vi.fn().mockResolvedValue(0),
+ getStats: vi.fn().mockResolvedValue({
+ totalEntries: 0,
+ entriesByNamespace: {},
+ entriesByType: {},
+ memoryUsage: 0,
+ avgQueryTime: 0,
+ avgSearchTime: 0,
+ }),
+ healthCheck: vi.fn().mockResolvedValue({
+ status: 'healthy',
+ components: {
+ storage: { status: 'healthy', latency: 0 },
+ index: { status: 'healthy', latency: 0 },
+ cache: { status: 'healthy', latency: 0 },
+ },
+ timestamp: Date.now(),
+ issues: [],
+ recommendations: [],
+ }),
+ };
+}
+
+// ===== Test Fixtures =====
+
+function createTestInsight(overrides: Partial<MemoryInsight> = {}): MemoryInsight {
+ return {
+ category: 'debugging',
+ summary: 'HNSW index requires initialization before search',
+ source: 'agent:tester',
+ confidence: 0.95,
+ ...overrides,
+ };
+}
+
+function createTestEntry(overrides: Partial<MemoryEntry> = {}): MemoryEntry {
+ const now = Date.now();
+ return {
+ id: 'entry-1',
+ key: 'insight:debugging:12345:0',
+ content: 'HNSW index requires initialization',
+ type: 'semantic',
+ namespace: 'learnings',
+ tags: ['insight', 'debugging'],
+ metadata: { confidence: 0.8, category: 'debugging' },
+ accessLevel: 'private',
+ createdAt: now,
+ updatedAt: now,
+ version: 1,
+ references: [],
+ accessCount: 0,
+ lastAccessedAt: now,
+ ...overrides,
+ };
+}
+
+// ===== Tests =====
+
+describe('LearningBridge', () => {
+ let bridge: LearningBridge;
+ let backend: ReturnType<typeof createMockBackend>;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ neuralImportShouldFail = false;
+ mockNeuralSystem.beginTask.mockReturnValue('traj-1');
+ mockNeuralSystem.findPatterns.mockResolvedValue([]);
+
+ backend = createMockBackend();
+ bridge = new LearningBridge(backend);
+ });
+
+ afterEach(() => {
+ bridge.destroy();
+ });
+
+ // ===== constructor =====
+
+ describe('constructor', () => {
+ it('should create with default config', () => {
+ const stats = bridge.getStats();
+ expect(stats.totalTrajectories).toBe(0);
+ expect(stats.neuralAvailable).toBe(false);
+ });
+
+ it('should create with custom config', () => {
+ const custom = new LearningBridge(backend, {
+ sonaMode: 'research',
+ confidenceDecayRate: 0.01,
+ accessBoostAmount: 0.05,
+ maxConfidence: 0.9,
+ minConfidence: 0.2,
+ ewcLambda: 5000,
+ consolidationThreshold: 20,
+ });
+
+ const stats = custom.getStats();
+ expect(stats.totalTrajectories).toBe(0);
+ custom.destroy();
+ });
+
+ it('should respect enabled=false', async () => {
+ const disabled = new LearningBridge(backend, { enabled: false });
+ const insight = createTestInsight();
+
+ await disabled.onInsightRecorded(insight, 'entry-1');
+
+ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();
+ expect(disabled.getStats().totalTrajectories).toBe(0);
+ disabled.destroy();
+ });
+ });
+
+ // ===== onInsightRecorded =====
+
+ describe('onInsightRecorded', () => {
+ it('should store trajectory when neural available', async () => {
+ const insight = createTestInsight();
+ await bridge.onInsightRecorded(insight, 'entry-1');
+
+ expect(mockNeuralSystem.beginTask).toHaveBeenCalledWith(insight.summary, 'general');
+ expect(mockNeuralSystem.recordStep).toHaveBeenCalledWith('traj-1', expect.objectContaining({
+ action: 'record:debugging',
+ reward: 0.95,
+ }));
+ expect(bridge.getStats().totalTrajectories).toBe(1);
+ });
+
+ it('should emit insight:learning-started event', async () => {
+ const handler = vi.fn();
+ bridge.on('insight:learning-started', handler);
+
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ expect(handler).toHaveBeenCalledWith({
+ entryId: 'entry-1',
+ category: 'debugging',
+ });
+ });
+
+ it('should no-op when disabled', async () => {
+ const disabled = new LearningBridge(backend, { enabled: false });
+
+ await disabled.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();
+ disabled.destroy();
+ });
+
+ it('should no-op when destroyed', async () => {
+ bridge.destroy();
+
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();
+ });
+
+ it('should handle neural unavailable gracefully', async () => {
+ neuralImportShouldFail = true;
+ const safeBridge = new LearningBridge(backend);
+ const handler = vi.fn();
+ safeBridge.on('insight:learning-started', handler);
+
+ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ // Event should still be emitted even without neural
+ expect(handler).toHaveBeenCalled();
+ expect(safeBridge.getStats().neuralAvailable).toBe(false);
+ safeBridge.destroy();
+ });
+
+ it('should pass hash embedding as stateEmbedding', async () => {
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ const stepArg = mockNeuralSystem.recordStep.mock.calls[0][1];
+ expect(stepArg.stateEmbedding).toBeInstanceOf(Float32Array);
+ expect(stepArg.stateEmbedding.length).toBe(768);
+ });
+
+ it('should create unique trajectory per entry', async () => {
+ mockNeuralSystem.beginTask
+ .mockReturnValueOnce('traj-1')
+ .mockReturnValueOnce('traj-2');
+
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: 'Second insight' }),
+ 'entry-2',
+ );
+
+ expect(bridge.getStats().totalTrajectories).toBe(2);
+ expect(bridge.getStats().activeTrajectories).toBe(2);
+ });
+
+ it('should survive beginTask throwing', async () => {
+ mockNeuralSystem.beginTask.mockImplementationOnce(() => {
+ throw new Error('Neural failure');
+ });
+
+ const handler = vi.fn();
+ bridge.on('insight:learning-started', handler);
+
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ // Should still emit event
+ expect(handler).toHaveBeenCalled();
+ });
+ });
+
+ // ===== onInsightAccessed =====
+
+ describe('onInsightAccessed', () => {
+ it('should boost confidence by accessBoostAmount', async () => {
+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ expect(backend.update).toHaveBeenCalledWith('entry-1', {
+ metadata: expect.objectContaining({ confidence: 0.53 }),
+ });
+ });
+
+ it('should cap confidence at maxConfidence', async () => {
+ const entry = createTestEntry({ metadata: { confidence: 0.99 } });
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ const updateCall = (backend.update as any).mock.calls[0];
+ expect(updateCall[1].metadata.confidence).toBeLessThanOrEqual(1.0);
+ });
+
+ it('should handle missing entry gracefully', async () => {
+ (backend.get as any).mockResolvedValueOnce(null);
+
+ // Should not throw
+ await bridge.onInsightAccessed('nonexistent');
+
+ expect(backend.update).not.toHaveBeenCalled();
+ });
+
+ it('should emit insight:accessed event', async () => {
+ const entry = createTestEntry({ metadata: { confidence: 0.7 } });
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ const handler = vi.fn();
+ bridge.on('insight:accessed', handler);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ expect(handler).toHaveBeenCalledWith({
+ entryId: 'entry-1',
+ newConfidence: expect.any(Number),
+ });
+ });
+
+ it('should update entry metadata in backend', async () => {
+ const entry = createTestEntry({
+ metadata: { confidence: 0.6, category: 'debugging', extra: 'preserved' },
+ });
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ const updateCall = (backend.update as any).mock.calls[0][1];
+ // Original metadata should be preserved alongside the updated confidence
+ expect(updateCall.metadata.category).toBe('debugging');
+ expect(updateCall.metadata.extra).toBe('preserved');
+ expect(updateCall.metadata.confidence).toBeCloseTo(0.63, 5);
+ });
+
+ it('should record neural step when trajectory exists', async () => {
+ // First create a trajectory
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ vi.clearAllMocks();
+
+ const entry = createTestEntry();
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ expect(mockNeuralSystem.recordStep).toHaveBeenCalledWith('traj-1', {
+ action: 'access',
+ reward: 0.03,
+ });
+ });
+
+ it('should not record neural step without trajectory', async () => {
+ const entry = createTestEntry();
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ // recordStep may have been called during initNeural on first method call,
+ // but not for this access since no trajectory exists for this entry
+ expect(mockNeuralSystem.recordStep).not.toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ action: 'access' }),
+ );
+ });
+
+ it('should use default 0.5 confidence when metadata lacks it', async () => {
+ const entry = createTestEntry({ metadata: {} });
+ (backend.get as any).mockResolvedValueOnce(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+
+ const updateCall = (backend.update as any).mock.calls[0][1];
+ expect(updateCall.metadata.confidence).toBeCloseTo(0.53, 5);
+ });
+
+ it('should no-op when disabled', async () => {
+ const disabled = new LearningBridge(backend, { enabled: false });
+
+ await disabled.onInsightAccessed('entry-1');
+
+ expect(backend.get).not.toHaveBeenCalled();
+ disabled.destroy();
+ });
+
+ it('should track boost stats', async () => {
+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });
+ (backend.get as any).mockResolvedValue(entry);
+
+ await bridge.onInsightAccessed('entry-1');
+ await bridge.onInsightAccessed('entry-1');
+
+ const stats = bridge.getStats();
+ expect(stats.avgConfidenceBoost).toBeCloseTo(0.03, 5);
+ });
+ });
+
+ // ===== consolidate =====
+
+ describe('consolidate', () => {
+ it('should complete active trajectories', async () => {
+ // Create enough trajectories to meet the threshold (default 10)
+ for (let i = 0; i < 10; i++) {
+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: `Insight ${i}` }),
+ `entry-${i}`,
+ );
+ }
+
+ const result = await bridge.consolidate();
+
+ expect(result.trajectoriesCompleted).toBe(10);
+ expect(result.patternsLearned).toBe(10);
+ expect(result.durationMs).toBeGreaterThanOrEqual(0);
+ });
+
+ it('should return early when below threshold', async () => {
+ // Only create 2 trajectories, below default threshold of 10
+ mockNeuralSystem.beginTask.mockReturnValueOnce('traj-1');
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ const result = await bridge.consolidate();
+
+ expect(result.trajectoriesCompleted).toBe(0);
+ expect(mockNeuralSystem.completeTask).not.toHaveBeenCalled();
+ });
+
+ it('should return early when neural unavailable', async () => {
+ neuralImportShouldFail = true;
+ const safeBridge = new LearningBridge(backend);
+
+ const result = await safeBridge.consolidate();
+
+ expect(result.trajectoriesCompleted).toBe(0);
+ safeBridge.destroy();
+ });
+
+ it('should clear completed trajectories', async () => {
+ for (let i = 0; i < 10; i++) {
+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: `Insight ${i}` }),
+ `entry-${i}`,
+ );
+ }
+
+ expect(bridge.getStats().activeTrajectories).toBe(10);
+
+ await bridge.consolidate();
+
+ expect(bridge.getStats().activeTrajectories).toBe(0);
+ });
+
+ it('should emit consolidation:completed event', async () => {
+ for (let i = 0; i < 10; i++) {
+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: `Insight ${i}` }),
+ `entry-${i}`,
+ );
+ }
+
+ const handler = vi.fn();
+ bridge.on('consolidation:completed', handler);
+
+ await bridge.consolidate();
+
+ expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+ trajectoriesCompleted: 10,
+ patternsLearned: 10,
+ }));
+ });
+
+ it('should track stats correctly', async () => {
+ for (let i = 0; i < 10; i++) {
+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: `Insight ${i}` }),
+ `entry-${i}`,
+ );
+ }
+
+ await bridge.consolidate();
+
+ const stats = bridge.getStats();
+ expect(stats.completedTrajectories).toBe(10);
+ expect(stats.totalConsolidations).toBe(1);
+ });
+
+ it('should handle completeTask failure for individual trajectories', async () => {
+ for (let i = 0; i < 10; i++) {
+ mockNeuralSystem.beginTask.mockReturnValueOnce(`traj-${i}`);
+ await bridge.onInsightRecorded(
+ createTestInsight({ summary: `Insight ${i}` }),
+ `entry-${i}`,
+ );
+ }
+
+ // Fail on 3rd trajectory
+ let callCount = 0;
+ mockNeuralSystem.completeTask.mockImplementation(async () => {
+ callCount++;
+ if (callCount === 3) throw new Error('Neural failure');
+ });
+
+ const result = await bridge.consolidate();
+
+ // 9 should succeed, 1 fails
+ expect(result.trajectoriesCompleted).toBe(9);
+ });
+
+ it('should respect custom consolidationThreshold', async () => {
+ const customBridge = new LearningBridge(backend, { consolidationThreshold: 2 });
+
+ mockNeuralSystem.beginTask.mockReturnValueOnce('traj-1').mockReturnValueOnce('traj-2');
+ await customBridge.onInsightRecorded(createTestInsight(), 'e-1');
+ await customBridge.onInsightRecorded(createTestInsight({ summary: 'Second' }), 'e-2');
+
+ const result = await customBridge.consolidate();
+
+ expect(result.trajectoriesCompleted).toBe(2);
+ customBridge.destroy();
+ });
+ });
+
+ // ===== decayConfidences =====
+
+ describe('decayConfidences', () => {
+ it('should decay entries older than 1 hour', async () => {
+ const twoHoursAgo = Date.now() - 2 * 3_600_000;
+ const entry = createTestEntry({
+ id: 'old-entry',
+ updatedAt: twoHoursAgo,
+ metadata: { confidence: 0.9 },
+ });
+ (backend.query as any).mockResolvedValueOnce([entry]);
+
+ const count = await bridge.decayConfidences('learnings');
+
+ expect(count).toBe(1);
+ expect(backend.update).toHaveBeenCalledWith('old-entry', {
+ metadata: expect.objectContaining({
+ confidence: expect.any(Number),
+ }),
+ });
+
+ const newConf = (backend.update as any).mock.calls[0][1].metadata.confidence;
+ // 0.9 - (0.005 * 2) = 0.89
+ expect(newConf).toBeCloseTo(0.89, 2);
+ });
+
+ it('should respect minConfidence floor', async () => {
+ const longAgo = Date.now() - 200 * 3_600_000; // 200 hours ago
+ const entry = createTestEntry({
+ id: 'ancient-entry',
+ updatedAt: longAgo,
+ metadata: { confidence: 0.5 },
+ });
+ (backend.query as any).mockResolvedValueOnce([entry]);
+
+ await bridge.decayConfidences('learnings');
+
+ const newConf = (backend.update as any).mock.calls[0][1].metadata.confidence;
+ expect(newConf).toBeGreaterThanOrEqual(0.1);
+ });
+
+ it('should skip recent entries', async () => {
+ const entry = createTestEntry({
+ id: 'recent-entry',
+ updatedAt: Date.now() - 30 * 60_000, // 30 minutes ago
+ metadata: { confidence: 0.8 },
+ });
+ (backend.query as any).mockResolvedValueOnce([entry]);
+
+ const count = await bridge.decayConfidences('learnings');
+
+ expect(count).toBe(0);
+ expect(backend.update).not.toHaveBeenCalled();
+ });
+
+ it('should return count of decayed entries', async () => {
+ const twoHoursAgo = Date.now() - 2 * 3_600_000;
+ const entries = [
+ createTestEntry({ id: 'e1', updatedAt: twoHoursAgo, metadata: { confidence: 0.9 } }),
+ createTestEntry({ id: 'e2', updatedAt: twoHoursAgo, metadata: { confidence: 0.7 } }),
+ createTestEntry({ id: 'e3', updatedAt: Date.now(), metadata: { confidence: 0.5 } }), // recent
+ ];
+ (backend.query as any).mockResolvedValueOnce(entries);
+
+ const count = await bridge.decayConfidences('learnings');
+
+ expect(count).toBe(2);
+ });
+
+ it('should handle empty namespace', async () => {
+ (backend.query as any).mockResolvedValueOnce([]);
+
+ const count = await bridge.decayConfidences('empty-ns');
+
+ expect(count).toBe(0);
+ });
+
+ it('should handle query failure gracefully', async () => {
+ (backend.query as any).mockRejectedValueOnce(new Error('DB error'));
+
+ const count = await bridge.decayConfidences('broken');
+
+ expect(count).toBe(0);
+ });
+
+ it('should track total decays in stats', async () => {
+ const old = Date.now() - 5 * 3_600_000;
+ (backend.query as any).mockResolvedValueOnce([
+ createTestEntry({ id: 'e1', updatedAt: old, metadata: { confidence: 0.9 } }),
+ ]);
+
+ await bridge.decayConfidences('learnings');
+
+ expect(bridge.getStats().totalDecays).toBe(1);
+ });
+ });
+
+ // ===== findSimilarPatterns =====
+
+ describe('findSimilarPatterns', () => {
+ it('should return patterns when neural available', async () => {
+ mockNeuralSystem.findPatterns.mockResolvedValueOnce([
+ { content: 'Pattern A', similarity: 0.9, category: 'debugging', confidence: 0.8 },
+ { content: 'Pattern B', similarity: 0.7, category: 'performance', confidence: 0.6 },
+ ]);
+
+ const patterns = await bridge.findSimilarPatterns('test query');
+
+ expect(patterns).toHaveLength(2);
+ expect(patterns[0].content).toBe('Pattern A');
+ expect(patterns[0].similarity).toBe(0.9);
+ expect(patterns[1].category).toBe('performance');
+ });
+
+ it('should return empty when neural unavailable', async () => {
+ neuralImportShouldFail = true;
+ const safeBridge = new LearningBridge(backend);
+
+ const patterns = await safeBridge.findSimilarPatterns('test');
+
+ expect(patterns).toHaveLength(0);
+ safeBridge.destroy();
+ });
+
+ it('should map results to PatternMatch format', async () => {
+ mockNeuralSystem.findPatterns.mockResolvedValueOnce([
+ { data: 'Raw data', score: 0.85, reward: 0.7 },
+ ]);
+
+ const patterns = await bridge.findSimilarPatterns('test');
+
+ expect(patterns).toHaveLength(1);
+ expect(patterns[0].content).toBe('Raw data');
+ expect(patterns[0].similarity).toBe(0.85);
+ expect(patterns[0].confidence).toBe(0.7);
+ expect(patterns[0].category).toBe('unknown');
+ });
+
+ it('should pass k parameter to neural', async () => {
+ await bridge.findSimilarPatterns('test', 3);
+
+ expect(mockNeuralSystem.findPatterns).toHaveBeenCalledWith(
+ expect.any(Float32Array),
+ 3,
+ );
+ });
+
+ it('should handle findPatterns throwing', async () => {
+ mockNeuralSystem.findPatterns.mockRejectedValueOnce(new Error('Neural error'));
+
+ const patterns = await bridge.findSimilarPatterns('test');
+
+ expect(patterns).toHaveLength(0);
+ });
+
+ it('should handle non-array result from findPatterns', async () => {
+ mockNeuralSystem.findPatterns.mockResolvedValueOnce(null);
+
+ const patterns = await bridge.findSimilarPatterns('test');
+
+ expect(patterns).toHaveLength(0);
+ });
+ });
+
+ // ===== getStats =====
+
+ describe('getStats', () => {
+ it('should return correct initial stats', () => {
+ const stats = bridge.getStats();
+
+ expect(stats.totalTrajectories).toBe(0);
+ expect(stats.completedTrajectories).toBe(0);
+ expect(stats.activeTrajectories).toBe(0);
+ expect(stats.totalConsolidations).toBe(0);
+ expect(stats.totalDecays).toBe(0);
+ expect(stats.avgConfidenceBoost).toBe(0);
+ });
+
+ it('should reflect operations in stats', async () => {
+ // Record an insight to get a trajectory
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ let stats = bridge.getStats();
+ expect(stats.totalTrajectories).toBe(1);
+ expect(stats.activeTrajectories).toBe(1);
+ expect(stats.neuralAvailable).toBe(true);
+
+ // Access to get boost stats
+ const entry = createTestEntry({ metadata: { confidence: 0.5 } });
+ (backend.get as any).mockResolvedValueOnce(entry);
+ await bridge.onInsightAccessed('entry-1');
+
+ stats = bridge.getStats();
+ expect(stats.avgConfidenceBoost).toBeCloseTo(0.03, 5);
+ });
+
+ it('should show neuralAvailable=false before init', () => {
+ const fresh = new LearningBridge(backend);
+ expect(fresh.getStats().neuralAvailable).toBe(false);
+ fresh.destroy();
+ });
+ });
+
+ // ===== destroy =====
+
+ describe('destroy', () => {
+ it('should set destroyed state', async () => {
+ bridge.destroy();
+
+ // Subsequent operations should no-op
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ expect(mockNeuralSystem.beginTask).not.toHaveBeenCalled();
+ });
+
+ it('should clear trajectories', async () => {
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ expect(bridge.getStats().activeTrajectories).toBe(1);
+
+ bridge.destroy();
+
+ expect(bridge.getStats().activeTrajectories).toBe(0);
+ });
+
+ it('should make subsequent onInsightRecorded no-op', async () => {
+ bridge.destroy();
+
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+
+ expect(bridge.getStats().totalTrajectories).toBe(0);
+ });
+
+ it('should make subsequent onInsightAccessed no-op', async () => {
+ bridge.destroy();
+
+ await bridge.onInsightAccessed('entry-1');
+
+ expect(backend.get).not.toHaveBeenCalled();
+ });
+
+ it('should make subsequent consolidate no-op', async () => {
+ bridge.destroy();
+
+ const result = await bridge.consolidate();
+
+ expect(result.trajectoriesCompleted).toBe(0);
+ });
+
+ it('should make subsequent decayConfidences no-op', async () => {
+ bridge.destroy();
+
+ const count = await bridge.decayConfidences('learnings');
+
+ expect(count).toBe(0);
+ });
+
+ it('should make subsequent findSimilarPatterns no-op', async () => {
+ bridge.destroy();
+
+ const patterns = await bridge.findSimilarPatterns('test');
+
+ expect(patterns).toHaveLength(0);
+ });
+
+ it('should call neural cleanup if available', async () => {
+ // Trigger neural init
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ vi.clearAllMocks();
+
+ bridge.destroy();
+
+ expect(mockNeuralSystem.cleanup).toHaveBeenCalled();
+ });
+
+ it('should remove all event listeners', () => {
+ bridge.on('insight:learning-started', () => {});
+ bridge.on('consolidation:completed', () => {});
+
+ bridge.destroy();
+
+ expect(bridge.listenerCount('insight:learning-started')).toBe(0);
+ expect(bridge.listenerCount('consolidation:completed')).toBe(0);
+ });
+ });
+
+ // ===== Neural init caching =====
+
+ describe('neural initialization', () => {
+ it('should only attempt neural import once', async () => {
+ await bridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ await bridge.onInsightRecorded(createTestInsight({ summary: 'Second' }), 'entry-2');
+
+ // NeuralLearningSystem constructor should only be called once
+ const neuralMod = await import('@claude-flow/neural');
+ expect(neuralMod.NeuralLearningSystem).toHaveBeenCalledTimes(1);
+ });
+
+ it('should cache failed init and not retry', async () => {
+ neuralImportShouldFail = true;
+ const safeBridge = new LearningBridge(backend);
+
+ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-1');
+ await safeBridge.onInsightRecorded(createTestInsight(), 'entry-2');
+
+ // Both calls should complete without error
+ expect(safeBridge.getStats().neuralAvailable).toBe(false);
+ safeBridge.destroy();
+ });
+ });
+});