/**
 * Tests for AutoMemoryBridge
 *
 * TDD London School (mock-first) tests for the bidirectional bridge
 * between Claude Code auto memory and AgentDB.
 */
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import * as fsSync from 'node:fs';
import * as path from 'node:path';
import { AutoMemoryBridge, resolveAutoMemoryDir, findGitRoot, parseMarkdownEntries, extractSummaries, formatInsightLine, hashContent, pruneTopicFile, hasSummaryLine, } from './auto-memory-bridge.js';
// ===== Mock Backend =====
function createMockBackend() {
    const storedEntries = [];
    return {
        storedEntries,
        initialize: vi.fn().mockResolvedValue(undefined),
        shutdown: vi.fn().mockResolvedValue(undefined),
        store: vi.fn().mockImplementation(async (entry) => {
            storedEntries.push(entry);
        }),
        get: vi.fn().mockResolvedValue(null),
        getByKey: vi.fn().mockResolvedValue(null),
        update: vi.fn().mockResolvedValue(null),
        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 = {}) {
    return {
        category: 'debugging',
        summary: 'HNSW index requires initialization before search',
        source: 'agent:tester',
        confidence: 0.95,
        ...overrides,
    };
}
// ===== Utility Function Tests =====
describe('resolveAutoMemoryDir', () => {
    it('should derive path from working directory', () => {
        const result = resolveAutoMemoryDir('/workspaces/my-project');
        expect(result).toContain('.claude/projects/');
        expect(result).toContain('memory');
        expect(result).not.toContain('//');
    });
    it('should replace slashes with dashes', () => {
        const result = resolveAutoMemoryDir('/workspaces/my-project');
        expect(result).toContain('workspaces-my-project');
    });
    it('should produce consistent paths for same input', () => {
        const a = resolveAutoMemoryDir('/workspaces/my-project');
        const b = resolveAutoMemoryDir('/workspaces/my-project');
        expect(a).toBe(b);
    });
});
describe('findGitRoot', () => {
    it('should find git root for a directory inside a repo', () => {
        // We know /workspaces/claude-flow is a git repo
        const root = findGitRoot('/workspaces/claude-flow/v3/@claude-flow/memory');
        expect(root).toBe('/workspaces/claude-flow');
    });
    it('should return the directory itself if it is the git root', () => {
        const root = findGitRoot('/workspaces/claude-flow');
        expect(root).toBe('/workspaces/claude-flow');
    });
    it('should return null for root filesystem', () => {
        // /proc is almost certainly not in a git repo
        const result = findGitRoot('/proc');
        expect(result).toBeNull();
    });
});
describe('parseMarkdownEntries', () => {
    it('should parse markdown with ## headings into entries', () => {
        const content = `# Main Title

## Section One
Content of section one.
More content here.

## Section Two
Content of section two.
`;
        const entries = parseMarkdownEntries(content);
        expect(entries).toHaveLength(2);
        expect(entries[0].heading).toBe('Section One');
        expect(entries[0].content).toContain('Content of section one');
        expect(entries[1].heading).toBe('Section Two');
    });
    it('should return empty array for content without ## headings', () => {
        const content = '# Only h1 heading\nSome text\n';
        const entries = parseMarkdownEntries(content);
        expect(entries).toHaveLength(0);
    });
    it('should handle multiple lines under a heading', () => {
        const content = `## Heading
Line 1
Line 2
Line 3
`;
        const entries = parseMarkdownEntries(content);
        expect(entries).toHaveLength(1);
        expect(entries[0].content).toContain('Line 1');
        expect(entries[0].content).toContain('Line 3');
    });
    it('should trim whitespace from section content', () => {
        const content = '## Padded\n\n  Text here  \n\n';
        const entries = parseMarkdownEntries(content);
        expect(entries[0].content).toBe('Text here');
    });
    it('should handle empty content', () => {
        expect(parseMarkdownEntries('')).toHaveLength(0);
    });
});
describe('extractSummaries', () => {
    it('should extract bullet points from content', () => {
        const content = `# Topic

- First summary
- Second summary
- See \`details.md\` for more
Some other text
`;
        const summaries = extractSummaries(content);
        expect(summaries).toHaveLength(2);
        expect(summaries[0]).toBe('First summary');
        expect(summaries[1]).toBe('Second summary');
    });
    it('should skip "See" references', () => {
        const content = '- Good item\n- See `file.md` for details\n';
        const summaries = extractSummaries(content);
        expect(summaries).toHaveLength(1);
        expect(summaries[0]).toBe('Good item');
    });
    it('should return empty array for content without bullets', () => {
        const content = 'No bullets here\n';
        const summaries = extractSummaries(content);
        expect(summaries).toHaveLength(0);
    });
    it('should strip metadata annotations from summaries', () => {
        const content = '- Use Int8 quantization _(agent:tester, 2026-02-08, conf: 0.95)_\n';
        const summaries = extractSummaries(content);
        expect(summaries).toHaveLength(1);
        expect(summaries[0]).toBe('Use Int8 quantization');
    });
    it('should handle summaries without annotations', () => {
        const content = '- Clean summary without annotation\n';
        const summaries = extractSummaries(content);
        expect(summaries[0]).toBe('Clean summary without annotation');
    });
});
describe('formatInsightLine', () => {
    it('should format insight as a markdown bullet', () => {
        const insight = createTestInsight();
        const line = formatInsightLine(insight);
        expect(line.startsWith('- HNSW index requires initialization before search')).toBe(true);
        expect(line).toContain('agent:tester');
        expect(line).toContain('0.95');
    });
    it('should include detail as indented content for multi-line details', () => {
        const insight = createTestInsight({
            detail: 'Line 1\nLine 2\nLine 3',
        });
        const line = formatInsightLine(insight);
        expect(line).toContain('  Line 1');
        expect(line).toContain('  Line 2');
    });
    it('should not add indented detail for single-line details', () => {
        const insight = createTestInsight({ detail: 'Short detail' });
        const line = formatInsightLine(insight);
        // Single-line detail should not produce indented lines
        expect(line.split('\n')).toHaveLength(1);
    });
});
describe('hashContent', () => {
    it('should produce consistent hashes', () => {
        const hash1 = hashContent('test content');
        const hash2 = hashContent('test content');
        expect(hash1).toBe(hash2);
    });
    it('should produce different hashes for different content', () => {
        const hash1 = hashContent('content A');
        const hash2 = hashContent('content B');
        expect(hash1).not.toBe(hash2);
    });
    it('should return a 16-character hex string', () => {
        const hash = hashContent('test');
        expect(hash).toMatch(/^[0-9a-f]{16}$/);
    });
});
describe('pruneTopicFile', () => {
    it('should not prune if under limit', () => {
        const content = '# Header\n\nSubheader\n- Item 1\n- Item 2\n';
        const result = pruneTopicFile(content, 100);
        expect(result).toBe(content);
    });
    it('should keep header and newest entries when pruning', () => {
        const lines = ['# Header', '', 'Description'];
        for (let i = 0; i < 20; i++) {
            lines.push(`- Entry ${i}`);
        }
        const content = lines.join('\n');
        const result = pruneTopicFile(content, 13);
        const resultLines = result.split('\n');
        expect(resultLines[0]).toBe('# Header');
        expect(resultLines).toHaveLength(13);
        expect(resultLines[resultLines.length - 1]).toBe('- Entry 19');
    });
});
describe('hasSummaryLine', () => {
    it('should find exact summary at start of bullet line', () => {
        const content = '- Use Int8 quantization _(source, date)_\n- Other item\n';
        expect(hasSummaryLine(content, 'Use Int8 quantization')).toBe(true);
    });
    it('should not match substrings inside other bullets', () => {
        const content = '- Do not use Int8 for this case\n';
        // "Use Int8" should NOT match because the line starts with "- Do not use..."
        expect(hasSummaryLine(content, 'Use Int8')).toBe(false);
    });
    it('should return false when summary is absent', () => {
        const content = '- Something else\n';
        expect(hasSummaryLine(content, 'Missing summary')).toBe(false);
    });
    it('should handle empty content', () => {
        expect(hasSummaryLine('', 'anything')).toBe(false);
    });
});
// ===== AutoMemoryBridge Tests =====
describe('AutoMemoryBridge', () => {
    let bridge;
    let backend;
    let testDir;
    beforeEach(() => {
        testDir = path.join('/tmp', `auto-memory-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
        fsSync.mkdirSync(testDir, { recursive: true });
        backend = createMockBackend();
        bridge = new AutoMemoryBridge(backend, {
            memoryDir: testDir,
            syncMode: 'on-session-end',
        });
    });
    afterEach(() => {
        bridge.destroy();
        if (fsSync.existsSync(testDir)) {
            fsSync.rmSync(testDir, { recursive: true, force: true });
        }
    });
    describe('constructor', () => {
        it('should initialize with default config', () => {
            const b = new AutoMemoryBridge(backend);
            expect(b.getMemoryDir()).toBeTruthy();
            b.destroy();
        });
        it('should use provided memory directory', () => {
            expect(bridge.getMemoryDir()).toBe(testDir);
        });
    });
    describe('getIndexPath', () => {
        it('should return path to MEMORY.md', () => {
            expect(bridge.getIndexPath()).toBe(path.join(testDir, 'MEMORY.md'));
        });
    });
    describe('getTopicPath', () => {
        it('should return path to topic file based on category', () => {
            const p = bridge.getTopicPath('debugging');
            expect(p).toBe(path.join(testDir, 'debugging.md'));
        });
        it('should use custom topic mapping', () => {
            const custom = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                topicMapping: { debugging: 'bugs.md' },
            });
            const p = custom.getTopicPath('debugging');
            expect(p).toBe(path.join(testDir, 'bugs.md'));
            custom.destroy();
        });
    });
    describe('recordInsight', () => {
        it('should store insight in AgentDB', async () => {
            const insight = createTestInsight();
            await bridge.recordInsight(insight);
            expect(backend.store).toHaveBeenCalledTimes(1);
            const storedEntry = backend.storedEntries[0];
            expect(storedEntry.namespace).toBe('learnings');
            expect(storedEntry.tags).toContain('insight');
            expect(storedEntry.tags).toContain('debugging');
        });
        it('should emit insight:recorded event', async () => {
            const handler = vi.fn();
            bridge.on('insight:recorded', handler);
            const insight = createTestInsight();
            await bridge.recordInsight(insight);
            expect(handler).toHaveBeenCalledWith(insight);
        });
        it('should write to files immediately in on-write mode', async () => {
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                syncMode: 'on-write',
            });
            const insight = createTestInsight();
            await bridge.recordInsight(insight);
            const topicPath = bridge.getTopicPath('debugging');
            expect(fsSync.existsSync(topicPath)).toBe(true);
            const content = fsSync.readFileSync(topicPath, 'utf-8');
            expect(content).toContain(insight.summary);
        });
        it('should not write to files immediately in on-session-end mode', async () => {
            const insight = createTestInsight();
            await bridge.recordInsight(insight);
            const topicPath = bridge.getTopicPath('debugging');
            expect(fsSync.existsSync(topicPath)).toBe(false);
        });
        it('should store confidence in metadata', async () => {
            await bridge.recordInsight(createTestInsight({ confidence: 0.42 }));
            const stored = backend.storedEntries[0];
            expect(stored.metadata.confidence).toBe(0.42);
        });
    });
    describe('syncToAutoMemory', () => {
        it('should flush buffered insights to files', async () => {
            await bridge.recordInsight(createTestInsight());
            await bridge.recordInsight(createTestInsight({
                category: 'performance',
                summary: 'Use Int8 quantization for 3.92x memory reduction',
            }));
            const result = await bridge.syncToAutoMemory();
            expect(result.synced).toBeGreaterThan(0);
            expect(result.categories).toContain('debugging');
            expect(result.categories).toContain('performance');
            expect(result.errors).toHaveLength(0);
            expect(fsSync.existsSync(bridge.getTopicPath('debugging'))).toBe(true);
            expect(fsSync.existsSync(bridge.getTopicPath('performance'))).toBe(true);
        });
        it('should create MEMORY.md index', async () => {
            await bridge.recordInsight(createTestInsight());
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getIndexPath())).toBe(true);
        });
        it('should emit sync:completed event', async () => {
            const handler = vi.fn();
            bridge.on('sync:completed', handler);
            await bridge.syncToAutoMemory();
            expect(handler).toHaveBeenCalledWith(expect.objectContaining({
                durationMs: expect.any(Number),
            }));
        });
        it('should not duplicate insights on repeated sync', async () => {
            await bridge.recordInsight(createTestInsight());
            await bridge.syncToAutoMemory();
            await bridge.syncToAutoMemory();
            const topicPath = bridge.getTopicPath('debugging');
            const content = fsSync.readFileSync(topicPath, 'utf-8');
            const matches = content.match(/HNSW index requires/g);
            expect(matches).toHaveLength(1);
        });
        it('should clear the insight buffer after sync', async () => {
            await bridge.recordInsight(createTestInsight());
            expect(bridge.getStatus().bufferedInsights).toBe(1);
            await bridge.syncToAutoMemory();
            expect(bridge.getStatus().bufferedInsights).toBe(0);
        });
        it('should skip AgentDB entries already synced from the buffer', async () => {
            // Record an insight (stored in buffer AND AgentDB)
            await bridge.recordInsight(createTestInsight());
            // Mock backend.query to return the same insight from AgentDB
            const mockEntry = {
                id: 'test-1',
                key: 'insight:debugging:12345',
                content: 'HNSW index requires initialization before search',
                tags: ['insight', 'debugging'],
                metadata: {
                    category: 'debugging',
                    summary: 'HNSW index requires initialization before search',
                    confidence: 0.95,
                },
            };
            backend.query.mockResolvedValueOnce([mockEntry]);
            await bridge.syncToAutoMemory();
            // Should only appear once
            const content = fsSync.readFileSync(bridge.getTopicPath('debugging'), 'utf-8');
            const matches = content.match(/HNSW index requires/g);
            expect(matches).toHaveLength(1);
        });
    });
    describe('importFromAutoMemory', () => {
        it('should import entries from existing markdown files', async () => {
            const topicContent = `# Debugging Insights

## Known Issues
- Always init HNSW before search
- SQLite WASM needs sql.js
`;
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), topicContent, 'utf-8');
            const result = await bridge.importFromAutoMemory();
            expect(result.imported).toBeGreaterThan(0);
            expect(result.files).toContain('debugging.md');
            // Should use bulkInsert, not individual store calls
            expect(backend.bulkInsert).toHaveBeenCalled();
        });
        it('should skip entries already in AgentDB', async () => {
            const topicContent = `# Test

## Existing
Already in DB
`;
            fsSync.writeFileSync(path.join(testDir, 'test.md'), topicContent, 'utf-8');
            // Mock backend to return existing entry with matching content hash
            backend.query.mockResolvedValue([{
                    id: 'existing-1',
                    metadata: { contentHash: hashContent('Already in DB') },
                }]);
            const result = await bridge.importFromAutoMemory();
            expect(result.skipped).toBeGreaterThan(0);
        });
        it('should return zero imported for non-existent directory', async () => {
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: '/tmp/nonexistent-auto-memory-dir-xyz',
            });
            const result = await bridge.importFromAutoMemory();
            expect(result.imported).toBe(0);
            expect(result.files).toHaveLength(0);
        });
        it('should batch imports with bulkInsert', async () => {
            // Create multiple files with multiple sections
            fsSync.writeFileSync(path.join(testDir, 'file1.md'), '## A\nContent A\n## B\nContent B\n', 'utf-8');
            fsSync.writeFileSync(path.join(testDir, 'file2.md'), '## C\nContent C\n', 'utf-8');
            await bridge.importFromAutoMemory();
            // bulkInsert should be called once with all entries
            expect(backend.bulkInsert).toHaveBeenCalledTimes(1);
            const batchArg = backend.bulkInsert.mock.calls[0][0];
            expect(batchArg).toHaveLength(3);
        });
    });
    describe('curateIndex', () => {
        it('should generate MEMORY.md from topic files', async () => {
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), '# Debugging\n\n- Init HNSW before search\n- Check embeddings dimension\n', 'utf-8');
            fsSync.writeFileSync(path.join(testDir, 'performance.md'), '# Performance\n\n- Use Int8 quantization\n', 'utf-8');
            await bridge.curateIndex();
            const indexContent = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            expect(indexContent).toContain('# Claude Flow V3 Project Memory');
            expect(indexContent).toContain('Init HNSW before search');
            expect(indexContent).toContain('Use Int8 quantization');
        });
        it('should stay under maxIndexLines', async () => {
            const lines = ['# Debugging', ''];
            for (let i = 0; i < 200; i++) {
                lines.push(`- Item ${i} is a debugging insight`);
            }
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), lines.join('\n'), 'utf-8');
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                maxIndexLines: 20,
            });
            await bridge.curateIndex();
            const indexContent = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            const indexLines = indexContent.split('\n');
            expect(indexLines.length).toBeLessThanOrEqual(20);
        });
        it('should strip metadata from summaries in the index', async () => {
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), '# Debugging\n\n- Fixed a bug _(agent:tester, 2026-02-08, conf: 0.90)_\n', 'utf-8');
            await bridge.curateIndex();
            const indexContent = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            expect(indexContent).toContain('- Fixed a bug');
            expect(indexContent).not.toContain('_(agent:tester');
        });
        it('should handle pruneStrategy=fifo by removing oldest entries', async () => {
            const lines = ['# Debugging', ''];
            for (let i = 0; i < 50; i++) {
                lines.push(`- Item ${i}`);
            }
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), lines.join('\n'), 'utf-8');
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                maxIndexLines: 10,
                pruneStrategy: 'fifo',
            });
            await bridge.curateIndex();
            const indexContent = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            // FIFO removes oldest (first) items, keeps newest
            expect(indexContent).toContain('Item 49');
            expect(indexContent).not.toContain('Item 0');
        });
    });
    describe('getStatus', () => {
        it('should report status for existing directory', async () => {
            fsSync.writeFileSync(path.join(testDir, 'MEMORY.md'), '# Memory\n- Item 1\n- Item 2\n', 'utf-8');
            const status = bridge.getStatus();
            expect(status.exists).toBe(true);
            expect(status.memoryDir).toBe(testDir);
            expect(status.files.length).toBeGreaterThan(0);
            expect(status.indexLines).toBeGreaterThanOrEqual(3);
        });
        it('should report status for non-existent directory', () => {
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: '/tmp/nonexistent-dir-xyz',
            });
            const status = bridge.getStatus();
            expect(status.exists).toBe(false);
            expect(status.files).toHaveLength(0);
        });
        it('should count buffered insights', async () => {
            await bridge.recordInsight(createTestInsight());
            await bridge.recordInsight(createTestInsight({ summary: 'Another insight' }));
            const status = bridge.getStatus();
            expect(status.bufferedInsights).toBe(2);
        });
        it('should report lastSyncTime after sync', async () => {
            expect(bridge.getStatus().lastSyncTime).toBe(0);
            await bridge.syncToAutoMemory();
            expect(bridge.getStatus().lastSyncTime).toBeGreaterThan(0);
        });
    });
    describe('recordInsight - key uniqueness', () => {
        it('should generate unique keys for rapid sequential inserts', async () => {
            // Record multiple insights as fast as possible (same ms possible)
            await bridge.recordInsight(createTestInsight({ summary: 'Insight A' }));
            await bridge.recordInsight(createTestInsight({ summary: 'Insight B' }));
            await bridge.recordInsight(createTestInsight({ summary: 'Insight C' }));
            // All three should have unique keys
            const keys = backend.storedEntries.map(e => e.key);
            const uniqueKeys = new Set(keys);
            expect(uniqueKeys.size).toBe(3);
        });
    });
    describe('syncToAutoMemory - error handling', () => {
        it('should emit sync:failed on backend query error', async () => {
            const handler = vi.fn();
            bridge.on('sync:failed', handler);
            // Make ensureMemoryDir throw
            backend.query.mockRejectedValueOnce(new Error('DB connection lost'));
            // Record an insight so there's something to sync
            await bridge.recordInsight(createTestInsight());
            // The sync should still succeed for the buffered part
            // because queryRecentInsights has its own try/catch
            const result = await bridge.syncToAutoMemory();
            expect(result.errors).toHaveLength(0);
        });
        it('should report errors for individual insight write failures', async () => {
            // Create a read-only file to force a write error
            const topicPath = bridge.getTopicPath('debugging');
            fsSync.writeFileSync(topicPath, '# Debugging\n\n- Existing\n', 'utf-8');
            fsSync.chmodSync(topicPath, 0o444); // read-only
            await bridge.recordInsight(createTestInsight());
            const result = await bridge.syncToAutoMemory();
            // Should have error from trying to write to read-only file
            expect(result.errors.length).toBeGreaterThan(0);
            // Restore permissions for cleanup
            fsSync.chmodSync(topicPath, 0o644);
        });
    });
    describe('syncToAutoMemory - append to existing topic file', () => {
        it('should append new insight to existing topic file', async () => {
            // Create initial topic file
            const topicPath = bridge.getTopicPath('debugging');
            fsSync.writeFileSync(topicPath, '# Debugging\n\n- Existing item\n', 'utf-8');
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                syncMode: 'on-write',
            });
            await bridge.recordInsight(createTestInsight({ summary: 'New insight' }));
            const content = fsSync.readFileSync(topicPath, 'utf-8');
            expect(content).toContain('Existing item');
            expect(content).toContain('New insight');
        });
        it('should prune topic file when it exceeds maxTopicFileLines', async () => {
            // Create a topic file near the limit
            const topicPath = bridge.getTopicPath('debugging');
            const lines = ['# Debugging', '', 'Description'];
            for (let i = 0; i < 500; i++) {
                lines.push(`- Entry ${i}`);
            }
            fsSync.writeFileSync(topicPath, lines.join('\n'), 'utf-8');
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                syncMode: 'on-write',
                maxTopicFileLines: 500,
            });
            await bridge.recordInsight(createTestInsight({ summary: 'Overflow insight' }));
            const content = fsSync.readFileSync(topicPath, 'utf-8');
            expect(content).toContain('Overflow insight');
            // Old entries near the top should have been pruned
            expect(content).not.toContain('Entry 0');
            // Header should be preserved
            expect(content).toContain('# Debugging');
        });
    });
    describe('syncToAutoMemory - classifyEntry coverage', () => {
        it('should classify by metadata category when present', async () => {
            const entry = {
                id: 'e1',
                key: 'insight:security:999:0',
                content: 'SQL injection found',
                tags: ['insight'],
                metadata: { category: 'security', summary: 'SQL injection found', confidence: 0.9 },
            };
            backend.query.mockResolvedValueOnce([entry]);
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getTopicPath('security'))).toBe(true);
            const content = fsSync.readFileSync(bridge.getTopicPath('security'), 'utf-8');
            expect(content).toContain('SQL injection found');
        });
        it('should classify by tags when metadata category is absent', async () => {
            const entry = {
                id: 'e2',
                key: 'insight:unknown:999:0',
                content: 'Performance is slow',
                tags: ['insight', 'performance', 'benchmark'],
                metadata: { summary: 'Performance is slow', confidence: 0.85 },
            };
            backend.query.mockResolvedValueOnce([entry]);
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getTopicPath('performance'))).toBe(true);
        });
        it('should default to project-patterns for unclassifiable entries', async () => {
            const entry = {
                id: 'e3',
                key: 'insight:misc:999:0',
                content: 'Miscellaneous note',
                tags: ['insight'],
                metadata: { summary: 'Miscellaneous note', confidence: 0.8 },
            };
            backend.query.mockResolvedValueOnce([entry]);
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getTopicPath('project-patterns'))).toBe(true);
        });
        it('should classify debugging tags correctly', async () => {
            const bugEntry = {
                id: 'e4',
                key: 'insight:bug:999:0',
                content: 'Found a bug',
                tags: ['insight', 'bug'],
                metadata: { summary: 'Found a bug', confidence: 0.9 },
            };
            backend.query.mockResolvedValueOnce([bugEntry]);
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getTopicPath('debugging'))).toBe(true);
        });
        it('should classify swarm/agent tags correctly', async () => {
            const swarmEntry = {
                id: 'e5',
                key: 'insight:swarm:999:0',
                content: 'Swarm completed successfully',
                tags: ['insight', 'swarm'],
                metadata: { summary: 'Swarm completed successfully', confidence: 0.9 },
            };
            backend.query.mockResolvedValueOnce([swarmEntry]);
            await bridge.syncToAutoMemory();
            expect(fsSync.existsSync(bridge.getTopicPath('swarm-results'))).toBe(true);
        });
    });
    describe('importFromAutoMemory - edge cases', () => {
        it('should emit import:completed event', async () => {
            const handler = vi.fn();
            bridge.on('import:completed', handler);
            fsSync.writeFileSync(path.join(testDir, 'test.md'), '## Section\nContent here\n', 'utf-8');
            await bridge.importFromAutoMemory();
            expect(handler).toHaveBeenCalledWith(expect.objectContaining({
                imported: expect.any(Number),
                durationMs: expect.any(Number),
            }));
        });
        it('should handle files with no ## headings', async () => {
            fsSync.writeFileSync(path.join(testDir, 'empty.md'), '# Just a title\nSome text without sections\n', 'utf-8');
            const result = await bridge.importFromAutoMemory();
            expect(result.imported).toBe(0);
            expect(result.files).toContain('empty.md');
        });
    });
    describe('curateIndex - edge cases', () => {
        it('should handle empty topic files', async () => {
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), '# Debugging\n\n', 'utf-8');
            await bridge.curateIndex();
            const content = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            // Should not include empty section
            expect(content).not.toContain('Debugging');
        });
        it('should emit index:curated event', async () => {
            const handler = vi.fn();
            bridge.on('index:curated', handler);
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), '# Debugging\n\n- An item\n', 'utf-8');
            await bridge.curateIndex();
            expect(handler).toHaveBeenCalledWith(expect.objectContaining({
                lines: expect.any(Number),
            }));
        });
        it('should handle pruneStrategy=lru same as fifo', async () => {
            const lines = ['# Debugging', ''];
            for (let i = 0; i < 50; i++) {
                lines.push(`- Item ${i}`);
            }
            fsSync.writeFileSync(path.join(testDir, 'debugging.md'), lines.join('\n'), 'utf-8');
            bridge.destroy();
            bridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                maxIndexLines: 10,
                pruneStrategy: 'lru',
            });
            await bridge.curateIndex();
            const indexContent = fsSync.readFileSync(bridge.getIndexPath(), 'utf-8');
            // LRU removes oldest (first) items, same as FIFO
            expect(indexContent).toContain('Item 49');
            expect(indexContent).not.toContain('Item 0');
        });
    });
    describe('destroy', () => {
        it('should clean up periodic sync timer', () => {
            const periodicBridge = new AutoMemoryBridge(backend, {
                memoryDir: testDir,
                syncMode: 'periodic',
                syncIntervalMs: 1000,
            });
            periodicBridge.destroy();
        });
        it('should remove all listeners', () => {
            bridge.on('insight:recorded', () => { });
            bridge.on('sync:completed', () => { });
            bridge.destroy();
            expect(bridge.listenerCount('insight:recorded')).toBe(0);
            expect(bridge.listenerCount('sync:completed')).toBe(0);
        });
    });
});
//# sourceMappingURL=auto-memory-bridge.test.js.map