escribano 0.1.0

package/dist/tests/db/repositories.test.js

@@ -0,0 +1,243 @@
+/**
+ * Repository Interface Tests
+ *
+ * These tests run against the interface, not the implementation.
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { generateId } from '../../db/helpers.js';
+import { createTestRepositories } from '../../db/index.js';
+// =============================================================================
+// Interface Test Factories
+// =============================================================================
+function runRecordingRepositoryTests(name, createRepo) {
+    describe(`RecordingRepository: ${name}`, () => {
+        let repo;
+        let cleanup;
+        beforeEach(() => {
+            const result = createRepo();
+            repo = result.repo;
+            cleanup = result.cleanup;
+        });
+        afterEach(() => {
+            cleanup();
+        });
+        it('saves and retrieves a recording', () => {
+            const id = generateId();
+            repo.save({
+                id,
+                video_path: '/path/to/video.mp4',
+                audio_mic_path: '/path/to/mic.ogg',
+                audio_system_path: null,
+                duration: 120.5,
+                captured_at: '2026-01-20T10:00:00Z',
+                status: 'raw',
+                processing_step: null,
+                source_type: 'cap',
+                source_metadata: null,
+                error_message: null,
+            });
+            const found = repo.findById(id);
+            expect(found).not.toBeNull();
+            expect(found.id).toBe(id);
+            expect(found.duration).toBe(120.5);
+            expect(found.status).toBe('raw');
+        });
+        it('returns null for non-existent recording', () => {
+            const found = repo.findById('nonexistent');
+            expect(found).toBeNull();
+        });
+        it('updates status and processing step', () => {
+            const id = generateId();
+            repo.save({
+                id,
+                video_path: null,
+                audio_mic_path: '/path/to/mic.ogg',
+                audio_system_path: null,
+                duration: 60,
+                captured_at: '2026-01-20T10:00:00Z',
+                status: 'raw',
+                processing_step: null,
+                source_type: 'cap',
+                source_metadata: null,
+                error_message: null,
+            });
+            repo.updateStatus(id, 'processing', 'clustering');
+            const found = repo.findById(id);
+            expect(found.status).toBe('processing');
+            expect(found.processing_step).toBe('clustering');
+        });
+        it('finds pending recordings', () => {
+            const id1 = generateId();
+            const id2 = generateId();
+            repo.save({
+                id: id1,
+                video_path: null,
+                audio_mic_path: '/path/1.ogg',
+                audio_system_path: null,
+                duration: 60,
+                captured_at: '2026-01-20T10:00:00Z',
+                status: 'raw',
+                processing_step: null,
+                source_type: 'cap',
+                source_metadata: null,
+                error_message: null,
+            });
+            repo.save({
+                id: id2,
+                video_path: null,
+                audio_mic_path: '/path/2.ogg',
+                audio_system_path: null,
+                duration: 60,
+                captured_at: '2026-01-20T11:00:00Z',
+                status: 'processed',
+                processing_step: 'complete',
+                source_type: 'cap',
+                source_metadata: null,
+                error_message: null,
+            });
+            const pending = repo.findPending();
+            expect(pending.some((p) => p.id === id1)).toBe(true);
+            expect(pending.some((p) => p.id === id2)).toBe(false);
+        });
+        it('deletes a recording', () => {
+            const id = generateId();
+            repo.save({
+                id,
+                video_path: null,
+                audio_mic_path: '/path/to/mic.ogg',
+                audio_system_path: null,
+                duration: 60,
+                captured_at: '2026-01-20T10:00:00Z',
+                status: 'raw',
+                processing_step: null,
+                source_type: 'cap',
+                source_metadata: null,
+                error_message: null,
+            });
+            repo.delete(id);
+            const found = repo.findById(id);
+            expect(found).toBeNull();
+        });
+    });
+}
+function runContextRepositoryTests(name, createRepos) {
+    describe(`ContextRepository: ${name}`, () => {
+        let contextRepo;
+        let recordingRepo;
+        let observationRepo;
+        let cleanup;
+        beforeEach(() => {
+            const result = createRepos();
+            contextRepo = result.contextRepo;
+            recordingRepo = result.recordingRepo;
+            observationRepo = result.observationRepo;
+            cleanup = result.cleanup;
+        });
+        afterEach(() => {
+            cleanup();
+        });
+        it('saves and retrieves a context', () => {
+            const id = generateId();
+            contextRepo.save({
+                id,
+                type: 'project',
+                name: 'escribano',
+                metadata: JSON.stringify({ version: '1.0' }),
+            });
+            const found = contextRepo.findById(id);
+            expect(found).not.toBeNull();
+            expect(found.id).toBe(id);
+            expect(found.name).toBe('escribano');
+        });
+        it('finds by type and name', () => {
+            const id = generateId();
+            contextRepo.save({
+                id,
+                type: 'app',
+                name: 'vscode',
+                metadata: null,
+            });
+            const found = contextRepo.findByTypeAndName('app', 'vscode');
+            expect(found).not.toBeNull();
+            expect(found.id).toBe(id);
+        });
+        it('links and unlinks observations', () => {
+            const recordingId = generateId();
+            const contextId = generateId();
+            const observationId = generateId();
+            // 1. Save Recording (required for observation FK)
+            recordingRepo.save({
+                id: recordingId,
+                video_path: null,
+                audio_mic_path: null,
+                audio_system_path: null,
+                duration: 0,
+                captured_at: new Date().toISOString(),
+                status: 'raw',
+                processing_step: null,
+                source_type: 'raw',
+                source_metadata: null,
+                error_message: null,
+            });
+            // 2. Save Observation (required for link FK)
+            observationRepo.saveBatch([
+                {
+                    id: observationId,
+                    recording_id: recordingId,
+                    type: 'visual',
+                    timestamp: 0,
+                    end_timestamp: null,
+                    image_path: null,
+                    ocr_text: 'test',
+                    vlm_description: null,
+                    vlm_raw_response: null,
+                    activity_type: null,
+                    apps: null,
+                    topics: null,
+                    text: null,
+                    audio_source: null,
+                    audio_type: null,
+                    embedding: null,
+                },
+            ]);
+            // 3. Save Context
+            contextRepo.save({
+                id: contextId,
+                type: 'topic',
+                name: 'database',
+                metadata: null,
+            });
+            // 4. Link
+            contextRepo.linkObservation(observationId, contextId, 0.95);
+            const links = contextRepo.getObservationLinks(contextId);
+            expect(links).toHaveLength(1);
+            expect(links[0].observation_id).toBe(observationId);
+            expect(links[0].confidence).toBe(0.95);
+            // 5. Unlink
+            contextRepo.unlinkObservation(observationId, contextId);
+            const linksAfter = contextRepo.getObservationLinks(contextId);
+            expect(linksAfter).toHaveLength(0);
+        });
+    });
+}
+// =============================================================================
+// Run Tests Against SQLite Implementation
+// =============================================================================
+runRecordingRepositoryTests('SQLite', () => {
+    // Create fresh test repositories for each test
+    const testRepos = createTestRepositories();
+    return {
+        repo: testRepos.recordings,
+        cleanup: testRepos.cleanup,
+    };
+});
+runContextRepositoryTests('SQLite', () => {
+    // Create fresh test repositories for each test
+    const testRepos = createTestRepositories();
+    return {
+        contextRepo: testRepos.contexts,
+        recordingRepo: testRepos.recordings,
+        observationRepo: testRepos.observations,
+        cleanup: testRepos.cleanup,
+    };
+});

package/dist/tests/domain/time-range.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { TimeRange } from '../../domain/time-range.js';
+describe('TimeRange Value Object', () => {
+    describe('overlapDuration', () => {
+        it('should return 0 when there is no overlap', () => {
+            const overlap = TimeRange.overlapDuration([0, 10], [20, 30]);
+            expect(overlap).toBe(0);
+        });
+        it('should calculate partial overlap correctly', () => {
+            // Overlap between [0, 10] and [5, 15] is [5, 10] = 5 seconds
+            const overlap = TimeRange.overlapDuration([0, 10], [5, 15]);
+            expect(overlap).toBe(5);
+        });
+        it('should handle range fully contained within another', () => {
+            const overlap = TimeRange.overlapDuration([0, 100], [10, 20]);
+            expect(overlap).toBe(10);
+        });
+        it('should handle segments fully contained within range', () => {
+            const overlap = TimeRange.overlapDuration([0, 10], [2, 8]);
+            expect(overlap).toBe(6);
+        });
+    });
+    describe('create', () => {
+        it('should throw for negative values', () => {
+            expect(() => TimeRange.create(-1, 10)).toThrow();
+        });
+        it('should throw for end < start', () => {
+            expect(() => TimeRange.create(10, 5)).toThrow();
+        });
+    });
+});

package/dist/tests/integration.test.js

@@ -0,0 +1,84 @@
+/**
+ * Integration Test - Simple E2E Pipeline Test
+ *
+ * Tests: Cap Adapter → Process Session → Output
+ */
+import { describe, expect, it, vi } from 'vitest';
+describe('Integration: CLI Pipeline', () => {
+    it('should list recordings', async () => {
+        const mockRecording = {
+            id: 'test-recording-1',
+            source: {
+                type: 'cap',
+                originalPath: '~/test.cap',
+                metadata: {
+                    platform: 'MacOS',
+                    pretty_name: 'Test Recording',
+                    segments: [
+                        {
+                            display: {
+                                path: 'content/segments/segment-0/display.mp4',
+                                fps: 37,
+                            },
+                            mic: {
+                                path: 'content/segments/segment-0/audio-input.ogg',
+                                start_time: 0,
+                            },
+                            cursor: 'content/segments/segment-0/cursor.json',
+                        },
+                    ],
+                },
+            },
+            videoPath: '~/test.cap/content/segments/segment-0/display.mp4',
+            audioMicPath: '~/test.cap/content/segments/segment-0/audio-input.ogg',
+            audioSystemPath: null,
+            duration: 0,
+            capturedAt: new Date('2025-01-08T12:00:00.000Z'),
+        };
+        const mockCapSource = {
+            getLatestRecording: vi.fn().mockResolvedValue(mockRecording),
+            listRecordings: vi.fn().mockResolvedValue([mockRecording]),
+        };
+        const recordings = await mockCapSource.listRecordings(10);
+        expect(recordings).toEqual([mockRecording]);
+        expect(mockCapSource.listRecordings).toHaveBeenCalledWith(10);
+    });
+    it('should get latest recording', async () => {
+        const mockRecording = {
+            id: 'latest-recording',
+            source: {
+                type: 'cap',
+                originalPath: '~/Library/Application Support/so.cap.desktop/recordings/test.cap',
+                metadata: {
+                    platform: 'MacOS',
+                    pretty_name: 'Latest Recording',
+                    segments: [
+                        {
+                            display: {
+                                path: 'content/segments/segment-0/display.mp4',
+                                fps: 37,
+                            },
+                            mic: {
+                                path: 'content/segments/segment-0/audio-input.ogg',
+                                start_time: 0,
+                            },
+                            cursor: 'content/segments/segment-0/cursor.json',
+                        },
+                    ],
+                },
+            },
+            videoPath: '/tmp/video.mp4',
+            audioMicPath: '/tmp/audio.ogg',
+            audioSystemPath: null,
+            duration: 0,
+            capturedAt: new Date('2025-01-08T14:30:00.000Z'),
+        };
+        const mockCapSource = {
+            getLatestRecording: vi.fn().mockResolvedValue(mockRecording),
+            listRecordings: vi.fn().mockResolvedValue([mockRecording]),
+        };
+        const recording = await mockCapSource.getLatestRecording();
+        expect(recording).toEqual(mockRecording);
+        expect(mockCapSource.getLatestRecording).toHaveBeenCalled();
+    });
+});

package/dist/tests/intelligence.adapter.test.js

@@ -0,0 +1,102 @@
+/**
+ * Intelligence Adapter Tests
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createIntelligenceService } from '../adapters/intelligence.adapter.js';
+const mockConfig = {
+    provider: 'ollama',
+    endpoint: 'http://localhost:11434/v1/chat/completions',
+    model: 'qwen3:32b',
+    maxRetries: 3,
+    timeout: 30000,
+};
+const mockTranscript = {
+    fullText: 'This is a debugging session about authentication errors.',
+    segments: [
+        {
+            id: 'seg-0',
+            start: 0,
+            end: 5,
+            text: 'I fixed the authentication bug.',
+        },
+        {
+            id: 'seg-1',
+            start: 5,
+            end: 10,
+            text: 'Used JWT tokens for security.',
+        },
+    ],
+    language: 'en',
+    duration: 10,
+};
+describe('IntelligenceService', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should create an intelligence service', () => {
+        const service = createIntelligenceService(mockConfig);
+        expect(service).toBeDefined();
+        expect(service.classify).toBeInstanceOf(Function);
+        expect(service.generate).toBeInstanceOf(Function);
+    });
+    it('should classify a debugging session', async () => {
+        const mockResponse = JSON.stringify({
+            message: {
+                content: JSON.stringify({
+                    meeting: 10,
+                    debugging: 90,
+                    tutorial: 15,
+                    learning: 20,
+                    working: 5,
+                }),
+            },
+        });
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => JSON.parse(mockResponse),
+        });
+        const service = createIntelligenceService(mockConfig);
+        const result = await service.classify(mockTranscript);
+        expect(result.debugging).toBe(90);
+        expect(result.meeting).toBe(10);
+        expect(result.tutorial).toBe(15);
+        expect(result.learning).toBe(20);
+        expect(result.working).toBe(5);
+    });
+    it('should retry on API failures', async () => {
+        let attempts = 0;
+        global.fetch = vi.fn().mockImplementation(async () => {
+            attempts++;
+            if (attempts < 3) {
+                throw new Error('API timeout');
+            }
+            return {
+                ok: true,
+                json: async () => ({
+                    message: {
+                        content: JSON.stringify({
+                            meeting: 80,
+                            debugging: 10,
+                            tutorial: 5,
+                            learning: 15,
+                            working: 5,
+                        }),
+                    },
+                }),
+            };
+        });
+        const service = createIntelligenceService(mockConfig);
+        const result = await service.classify(mockTranscript);
+        expect(attempts).toBe(3);
+        expect(result.meeting).toBe(80);
+    });
+    it('should handle fetch errors correctly', async () => {
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+        });
+        const service = createIntelligenceService(mockConfig);
+        await expect(service.classify(mockTranscript)).rejects.toThrow('Classification failed after 3 retries');
+    });
+});

package/dist/tests/intelligence.ollama.adapter.test.js

@@ -0,0 +1,178 @@
+/**
+ * Intelligence Adapter Tests
+ */
+import { fetch as undiciFetch } from 'undici';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createOllamaIntelligenceService } from '../adapters/intelligence.ollama.adapter.js';
+const mockFetch = vi.mocked(undiciFetch);
+// Mock node:fs
+vi.mock('node:fs', () => ({
+    readFileSync: vi.fn((path) => {
+        if (path.includes('.jpg') || path.includes('.png')) {
+            return Buffer.from('fake-image-data');
+        }
+        if (path.includes('.md')) {
+            return '{{TRANSCRIPT_ALL}} {{TRANSCRIPT_SEGMENTS}} {{VISUAL_LOG}} {{CLASSIFICATION_SUMMARY}} {{METADATA}} {{LANGUAGE}} {{SPEAKERS}} {{KEY_MOMENTS}} {{ACTION_ITEMS}} {{TECHNICAL_TERMS}} {{CODE_SNIPPETS}}';
+        }
+        return '';
+    }),
+}));
+// Mock undici
+vi.mock('undici', () => ({
+    Agent: vi.fn(),
+    fetch: vi.fn(),
+}));
+const mockConfig = {
+    provider: 'ollama',
+    endpoint: 'http://localhost:11434/v1/chat/completions',
+    model: 'qwen3:32b',
+    generationModel: 'qwen2.5:72b',
+    visionModel: 'minicpm-v:8b',
+    maxRetries: 3,
+    timeout: 30000,
+    keepAlive: '10m',
+    maxContextSize: 131072,
+    embedding: {
+        model: 'nomic-embed-text',
+        similarityThreshold: 0.75,
+    },
+    vlmBatchSize: 4,
+    vlmMaxTokens: 2000,
+    mlxSocketPath: '/tmp/escribano-mlx.sock',
+};
+const mockTranscript = {
+    fullText: 'This is a debugging session about authentication errors.',
+    segments: [
+        {
+            id: 'seg-0',
+            start: 0,
+            end: 5,
+            text: 'I fixed the authentication bug.',
+        },
+        {
+            id: 'seg-1',
+            start: 5,
+            end: 10,
+            text: 'Used JWT tokens for security.',
+        },
+    ],
+    language: 'en',
+    duration: 10,
+};
+describe('IntelligenceService', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should create an intelligence service', () => {
+        const service = createOllamaIntelligenceService(mockConfig);
+        expect(service).toBeDefined();
+        expect(service.classify).toBeInstanceOf(Function);
+        expect(service.classifySegment).toBeInstanceOf(Function);
+        expect(service.generate).toBeInstanceOf(Function);
+        expect(service.describeImages).toBeInstanceOf(Function);
+    });
+    it('should describe images', async () => {
+        // Mock response for single image VLM calls (sequential processing)
+        // The API returns a pipe-delimited format: description | activity | apps | topics
+        // Apps and topics are comma-separated lists (not JSON arrays)
+        mockFetch
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                message: {
+                    content: 'description: A cat sitting on a mat | activity: observing | apps: Photos | topics: animals, pets',
+                },
+                done: true,
+                done_reason: 'stop',
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                message: {
+                    content: 'description: A dog chasing a ball | activity: playing | apps: Camera | topics: animals, play',
+                },
+                done: true,
+                done_reason: 'stop',
+            }),
+        });
+        const service = createOllamaIntelligenceService(mockConfig);
+        const result = await service.describeImages([
+            { imagePath: '/path/to/cat.jpg', timestamp: 10 },
+            { imagePath: '/path/to/dog.jpg', timestamp: 20 },
+        ]);
+        expect(result).toHaveLength(2);
+        expect(result[0].description).toBe('A cat sitting on a mat');
+        expect(result[0].activity).toBe('observing');
+        expect(result[0].apps).toContain('Photos');
+        expect(result[0].topics).toContain('animals');
+        expect(result[1].description).toBe('A dog chasing a ball');
+        expect(result[1].activity).toBe('playing');
+        expect(result[1].apps).toContain('Camera');
+        expect(result[1].topics).toContain('play');
+    });
+    it('should classify a debugging session', async () => {
+        const mockResponse = JSON.stringify({
+            message: {
+                content: JSON.stringify({
+                    meeting: 10,
+                    debugging: 90,
+                    tutorial: 15,
+                    learning: 20,
+                    working: 5,
+                }),
+            },
+            done: true,
+            done_reason: 'stop',
+        });
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: async () => JSON.parse(mockResponse),
+        });
+        const service = createOllamaIntelligenceService(mockConfig);
+        const result = await service.classify(mockTranscript);
+        expect(result.debugging).toBe(90);
+        expect(result.meeting).toBe(10);
+        expect(result.tutorial).toBe(15);
+        expect(result.learning).toBe(20);
+        expect(result.working).toBe(5);
+    });
+    it('should retry on API failures', async () => {
+        let attempts = 0;
+        mockFetch.mockImplementation(async () => {
+            attempts++;
+            if (attempts < 3) {
+                throw new Error('API timeout');
+            }
+            return {
+                ok: true,
+                json: async () => ({
+                    message: {
+                        content: JSON.stringify({
+                            meeting: 80,
+                            debugging: 10,
+                            tutorial: 5,
+                            learning: 15,
+                            working: 5,
+                        }),
+                    },
+                    done: true,
+                    done_reason: 'stop',
+                }),
+            };
+        });
+        const service = createOllamaIntelligenceService(mockConfig);
+        const result = await service.classify(mockTranscript);
+        expect(attempts).toBe(3);
+        expect(result.meeting).toBe(80);
+    });
+    it('should handle fetch errors correctly', async () => {
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+        });
+        const service = createOllamaIntelligenceService(mockConfig);
+        await expect(service.classify(mockTranscript)).rejects.toThrow('Request failed after 3 retries');
+    });
+});