escribano 0.1.0

package/dist/stats/observer.js

@@ -0,0 +1,65 @@
+import { pipelineEvents } from '../pipeline/events.js';
+let currentRunId = null;
+let statsRepo = null;
+export function setupStatsObserver(repo) {
+    statsRepo = repo;
+    pipelineEvents.on('run:start', (data) => {
+        currentRunId = data.runId;
+        repo.createRun({
+            id: data.runId,
+            recording_id: data.recordingId,
+            run_type: data.runType,
+            status: 'running',
+            started_at: new Date(data.timestamp).toISOString(),
+            metadata: data.metadata ? JSON.stringify(data.metadata) : undefined,
+        });
+    });
+    pipelineEvents.on('run:end', (data) => {
+        if (!currentRunId)
+            return;
+        const startedAt = data.timestamp;
+        repo.updateRun(currentRunId, {
+            status: data.status,
+            completed_at: new Date(data.timestamp).toISOString(),
+            total_duration_ms: data.durationMs,
+            error_message: data.error,
+        });
+        if (data.status !== 'cancelled') {
+            currentRunId = null;
+        }
+    });
+    pipelineEvents.on('phase:start', (data) => {
+        if (!data.runId)
+            return;
+        repo.createStat({
+            id: data.phaseId,
+            run_id: data.runId,
+            phase: data.phase,
+            status: 'running',
+            started_at: new Date(data.timestamp).toISOString(),
+            items_total: data.itemsTotal,
+        });
+    });
+    pipelineEvents.on('phase:end', (data) => {
+        repo.updateStat(data.phaseId, {
+            status: data.status,
+            completed_at: new Date(data.timestamp).toISOString(),
+            duration_ms: data.durationMs,
+            items_processed: data.itemsProcessed,
+            metadata: data.metadata ? JSON.stringify(data.metadata) : undefined,
+        });
+    });
+}
+export function cancelCurrentRun() {
+    if (currentRunId && statsRepo) {
+        statsRepo.updateRun(currentRunId, {
+            status: 'cancelled',
+            completed_at: new Date().toISOString(),
+            total_duration_ms: 0,
+        });
+        currentRunId = null;
+    }
+}
+export function getCurrentRunId() {
+    return currentRunId;
+}

package/dist/stats/repository.js

@@ -0,0 +1,36 @@
+export function createStatsRepository(db) {
+    const stmts = {
+        insertRun: db.prepare(`
+      INSERT INTO processing_runs (id, recording_id, run_type, status, started_at, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `),
+        updateRun: db.prepare(`
+      UPDATE processing_runs 
+      SET status = ?, completed_at = ?, total_duration_ms = ?, error_message = ?
+      WHERE id = ?
+    `),
+        insertStat: db.prepare(`
+      INSERT INTO processing_stats (id, run_id, phase, status, started_at, items_total)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `),
+        updateStat: db.prepare(`
+      UPDATE processing_stats 
+      SET status = ?, completed_at = ?, duration_ms = ?, items_processed = ?, metadata = ?
+      WHERE id = ?
+    `),
+    };
+    return {
+        createRun(run) {
+            stmts.insertRun.run(run.id, run.recording_id, run.run_type, run.status, run.started_at, run.metadata ?? null);
+        },
+        updateRun(id, updates) {
+            stmts.updateRun.run(updates.status, updates.completed_at, updates.total_duration_ms, updates.error_message ?? null, id);
+        },
+        createStat(stat) {
+            stmts.insertStat.run(stat.id, stat.run_id, stat.phase, stat.status, stat.started_at, stat.items_total ?? null);
+        },
+        updateStat(id, updates) {
+            stmts.updateStat.run(updates.status, updates.completed_at, updates.duration_ms, updates.items_processed ?? null, updates.metadata ?? null, id);
+        },
+    };
+}

package/dist/stats/resource-tracker.js

@@ -0,0 +1,86 @@
+import os from 'node:os';
+import pidusage from 'pidusage';
+export class ResourceTracker {
+    resources = new Map();
+    samples = new Map();
+    interval = null;
+    running = false;
+    register(resource) {
+        const name = resource.getResourceName();
+        if (!this.resources.has(name)) {
+            this.resources.set(name, resource);
+            this.samples.set(name, { memories: [], cpus: [] });
+        }
+    }
+    async start(intervalMs = 1000) {
+        if (this.running)
+            return;
+        this.running = true;
+        // Register nodejs itself if not already registered
+        if (!this.resources.has('nodejs')) {
+            this.register({
+                getResourceName: () => 'nodejs',
+                getPid: () => process.pid,
+            });
+        }
+        // Initial sample
+        await this.sample();
+        this.interval = setInterval(() => {
+            this.sample().catch(() => { });
+        }, intervalMs);
+    }
+    async sample() {
+        for (const [name, resource] of this.resources) {
+            const pid = resource.getPid();
+            if (!pid)
+                continue;
+            try {
+                const stats = await pidusage(pid);
+                const sample = this.samples.get(name);
+                if (sample) {
+                    sample.memories.push(stats.memory / 1024 / 1024);
+                    sample.cpus.push(stats.cpu);
+                }
+            }
+            catch {
+                // Process exited or not found - skip
+            }
+        }
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.running = false;
+        const result = {};
+        for (const [name, sample] of this.samples) {
+            if (sample.memories.length === 0)
+                continue;
+            const avgMem = sample.memories.reduce((a, b) => a + b, 0) / sample.memories.length;
+            const avgCpu = sample.cpus.reduce((a, b) => a + b, 0) / sample.cpus.length;
+            result[name] = {
+                peakMemoryMB: Math.round(Math.max(...sample.memories)),
+                avgMemoryMB: Math.round(avgMem),
+                peakCpuPercent: Math.round(Math.max(...sample.cpus) * 10) / 10,
+                avgCpuPercent: Math.round(avgCpu * 10) / 10,
+                sampleCount: sample.memories.length,
+            };
+        }
+        // Reset samples for next phase
+        for (const name of this.samples.keys()) {
+            this.samples.set(name, { memories: [], cpus: [] });
+        }
+        return result;
+    }
+    getSystemInfo() {
+        return {
+            totalMemoryGB: Math.round(os.totalmem() / 1024 / 1024 / 1024),
+            cpuCores: os.cpus().length,
+            platform: process.platform,
+        };
+    }
+    isRunning() {
+        return this.running;
+    }
+}

package/dist/stats/types.js

@@ -0,0 +1 @@
+export {};

package/dist/test-classification-prompts.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test different classification prompts to find the best approach
+ * for handling mixed-type sessions
+ */
+import { createStorageService } from './adapters/storage.adapter.js';
+// Test Prompts
+const PROMPTS = {
+    // Approach A: Current style but clearer
+    strictSingle: `You are a session classifier. Analyze this transcript and output ONLY valid JSON.
+
+Session types:
+- meeting: Conversations, interviews, discussions between people
+- debugging: Fixing issues, troubleshooting, error analysis
+- tutorial: Teaching, explaining, demonstrating how to do something
+- learning: Researching, studying, exploring new concepts
+
+Output exactly this JSON structure:
+{ "type": "meeting|debugging|tutorial|learning", "confidence": 0.0-1.0 }
+
+Transcript: {{TRANSCRIPT}}`,
+    // Approach B: Multi-label scoring
+    multiLabel: `Rate how much this transcript matches each session type (0-100):
+
+Session types:
+- meeting: Conversations, interviews, discussions between people
+- debugging: Fixing issues, troubleshooting, error analysis
+- tutorial: Teaching, explaining, demonstrating how to do something
+- learning: Researching, studying, exploring new concepts
+
+Output JSON with all types scored:
+{ "classifications": { "meeting": 85, "debugging": 10, "tutorial": 20, "learning": 45 } }
+
+Transcript: {{TRANSCRIPT}}`,
+    // Approach C: Primary + Secondary
+    primarySecondary: `Identify the PRIMARY type and any SECONDARY types that apply.
+
+Session types:
+- meeting: Conversations, interviews, discussions between people
+- debugging: Fixing issues, troubleshooting, error analysis
+- tutorial: Teaching, explaining, demonstrating how to do something
+- learning: Researching, studying, exploring new concepts
+
+Output JSON with structure shown:
+{ "primary": { "type": "meeting|debugging|tutorial|learning", "confidence": 0.0-1.0 }, "secondary": ["type1", "type2"] }
+
+Transcript: {{TRANSCRIPT}}`,
+    // Approach D: Array of applicable types
+    arrayTypes: `List ALL session types that apply with confidence scores.
+
+Session types:
+- meeting: Conversations, interviews, discussions between people
+- debugging: Fixing issues, troubleshooting, error analysis
+- tutorial: Teaching, explaining, demonstrating how to do something
+- learning: Researching, studying, exploring new concepts
+
+Output JSON with array of applicable types (include if confidence > 0.3):
+{ "types": [ {"type": "meeting", "confidence": 0.85} ] }
+
+Transcript: {{TRANSCRIPT}}`,
+};
+async function testPrompt(name, prompt, transcript, intelligenceConfig) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`Testing: ${name}`);
+    console.log(`${'='.repeat(60)}`);
+    const finalPrompt = prompt.replace('{{TRANSCRIPT}}', transcript.fullText);
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000000);
+        const response = await fetch(intelligenceConfig.endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: intelligenceConfig.model,
+                messages: [{ role: 'system', content: finalPrompt }],
+                stream: false,
+                format: 'json',
+                temperature: 0.3,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        console.log('Result:');
+        console.log(JSON.stringify(result, null, 2));
+        return result;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            console.error('Error: Request timed out after 30s');
+        }
+        else {
+            console.error('Error:', error);
+        }
+        return null;
+    }
+}
+async function main() {
+    const sessionId = process.argv[2];
+    if (!sessionId) {
+        console.error('Usage: pnpm run test-prompts <session-id>');
+        console.error('Example: pnpm run test-prompts "Your Recording.cap"');
+        process.exit(1);
+    }
+    console.log(`\n🔍 Testing classification prompts for: ${sessionId}`);
+    const storage = createStorageService();
+    const session = await storage.loadSession(sessionId);
+    if (!session || !session.transcripts || session.transcripts.length === 0) {
+        console.error(`\n❌ Session not found or has no transcripts: ${sessionId}`);
+        console.error('\nTo find sessions, run:');
+        console.error('  pnpm run list');
+        process.exit(1);
+    }
+    const transcript = session.transcripts[0].transcript;
+    console.log(`✓ Transcript length: ${transcript.fullText.length} chars`);
+    console.log(`✓ Number of segments: ${transcript.segments.length}`);
+    console.log(`✓ Audio source: ${session.transcripts[0].source}`);
+    console.log(`\n⏱️  Running 4 classification tests...\n`);
+    // Intelligence config
+    const intelligenceConfig = {
+        provider: 'ollama',
+        endpoint: 'http://localhost:11434/v1/chat/completions',
+        model: 'qwen3:32b',
+        maxRetries: 1,
+        timeout: 3000000,
+    };
+    // Test each prompt
+    const results = {};
+    let testNum = 1;
+    for (const [name, prompt] of Object.entries(PROMPTS)) {
+        console.log(`\n[${testNum}/4] Running test...`);
+        results[name] = await testPrompt(name, prompt, transcript, intelligenceConfig);
+        testNum++;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    // Summary
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('📊 FINAL SUMMARY');
+    console.log(`${'='.repeat(60)}`);
+    for (const [name, result] of Object.entries(results)) {
+        console.log(`\n${name
+            .toUpperCase()
+            .replace(/([A-Z])/g, ' $1')
+            .trim()}:`);
+        if (result) {
+            // Try to extract key info for quick comparison
+            if (result.type) {
+                console.log(`  Primary Type: ${result.type}`);
+                if (result.confidence)
+                    console.log(`  Confidence: ${(result.confidence * 100).toFixed(0)}%`);
+            }
+            else if (result.classifications) {
+                console.log('  Scores:', JSON.stringify(result.classifications));
+            }
+            else if (result.primary) {
+                console.log(`  Primary: ${result.primary.type} (${(result.primary.confidence * 100).toFixed(0)}%)`);
+                if (result.secondary?.length)
+                    console.log(`  Secondary: [${result.secondary.join(', ')}]`);
+            }
+            else if (result.types) {
+                console.log(`  Types: ${result.types.map((t) => `${t.type} (${(t.confidence * 100).toFixed(0)}%)`).join(', ')}`);
+            }
+            else {
+                console.log(`  Raw:`, JSON.stringify(result));
+            }
+        }
+        else {
+            console.log('  ❌ Failed or timed out');
+        }
+    }
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('✅ All tests complete!');
+    console.log(`${'='.repeat(60)}\n`);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

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

@@ -0,0 +1,75 @@
+/**
+ * Cap Adapter Tests
+ */
+import { describe, expect, it } from 'vitest';
+import { createCapSource } from '../adapters/cap.adapter';
+describe('Cap Adapter', () => {
+    it('should create a CapSource', () => {
+        const capSource = createCapSource({
+            recordingsPath: '~/tmp/recordings',
+        });
+        expect(capSource).toBeDefined();
+        expect(capSource.getLatestRecording).toBeInstanceOf(Function);
+    });
+    it('should handle nonexistent directory gracefully', async () => {
+        const capSource = createCapSource({
+            recordingsPath: '/nonexistent/path',
+        });
+        const latest = await capSource.getLatestRecording();
+        expect(latest).toBeNull();
+    });
+    it('should validate Cap recording metadata structure', async () => {
+        const mockMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+            segments: [
+                {
+                    display: {
+                        path: 'content/segments/segment-0/display.mp4',
+                        fps: 37,
+                    },
+                    mic: {
+                        path: 'content/segments/segment-0/audio-input.ogg',
+                        start_time: -0.032719958,
+                    },
+                    cursor: 'content/segments/segment-0/cursor.json',
+                },
+            ],
+        };
+        expect(mockMeta.segments).toBeDefined();
+        expect(mockMeta.segments[0]).toBeDefined();
+        expect(mockMeta.segments[0].display?.path).toBe('content/segments/segment-0/display.mp4');
+        expect(mockMeta.segments[0].mic?.path).toBe('content/segments/segment-0/audio-input.ogg');
+    });
+    it('should identify recordings without mic/audio field', async () => {
+        const mockMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+            segments: [
+                {
+                    display: {
+                        path: 'content/segments/segment-0/display.mp4',
+                        fps: 37,
+                    },
+                    cursor: 'content/segments/segment-0/cursor.json',
+                },
+            ],
+        };
+        expect(mockMeta.segments[0]?.mic).toBeUndefined();
+    });
+    it('should identify missing segments array', async () => {
+        const invalidMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+        };
+        expect(invalidMeta.segments).toBeUndefined();
+    });
+    it('should identify empty segments array', async () => {
+        const invalidMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+            segments: [],
+        };
+        expect(invalidMeta.segments?.length).toBe(0);
+    });
+});

package/dist/tests/capture.cap.adapter.test.js

@@ -0,0 +1,69 @@
+/**
+ * Cap Adapter Tests
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { createCapCaptureSource } from '../adapters/capture.cap.adapter.js';
+// Mock VideoService
+const mockVideoService = {
+    extractFramesAtInterval: vi.fn(),
+    extractFramesAtTimestamps: vi.fn(),
+    extractFramesAtTimestampsBatch: vi.fn(),
+    getMetadata: vi
+        .fn()
+        .mockResolvedValue({ duration: 300, width: 1920, height: 1080, fps: 30 }),
+    detectSceneChanges: vi.fn(),
+    runVisualIndexing: vi.fn(),
+};
+describe('Cap Adapter', () => {
+    it('should create a CapSource', () => {
+        const capSource = createCapCaptureSource({ recordingsPath: '~/tmp/recordings' }, mockVideoService);
+        expect(capSource).toBeDefined();
+        expect(capSource.getLatestRecording).toBeInstanceOf(Function);
+    });
+    it('should handle nonexistent directory gracefully', async () => {
+        const capSource = createCapCaptureSource({ recordingsPath: '/nonexistent/path' }, mockVideoService);
+        const latest = await capSource.getLatestRecording();
+        expect(latest).toBeNull();
+    });
+    it('should validate Cap recording metadata structure', async () => {
+        const mockMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+            segments: [
+                {
+                    display: {
+                        path: 'content/segments/segment-0/display.mp4',
+                        fps: 37,
+                    },
+                    mic: {
+                        path: 'content/segments/segment-0/audio-input.ogg',
+                        start_time: -0.032719958,
+                    },
+                    cursor: 'content/segments/segment-0/cursor.json',
+                },
+            ],
+        };
+        expect(mockMeta.segments).toBeDefined();
+        expect(mockMeta.segments[0]).toBeDefined();
+        expect(mockMeta.segments[0].display?.path).toBe('content/segments/segment-0/display.mp4');
+        expect(mockMeta.segments[0].mic?.path).toBe('content/segments/segment-0/audio-input.ogg');
+    });
+    it('should identify recordings without mic/audio field', async () => {
+        const mockMeta = {
+            segments: [{}],
+        };
+        expect(mockMeta.segments?.[0]?.mic).toBeUndefined();
+    });
+    it('should identify missing segments array', async () => {
+        const invalidMeta = {};
+        expect(invalidMeta.segments).toBeUndefined();
+    });
+    it('should identify empty segments array', async () => {
+        const invalidMeta = {
+            platform: 'MacOS',
+            pretty_name: 'Cap 2026-01-08 at 16.46.37',
+            segments: [],
+        };
+        expect(invalidMeta.segments?.length).toBe(0);
+    });
+});

package/dist/tests/classify-session.test.js

@@ -0,0 +1,140 @@
+/**
+ * Classify Session Action Tests
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { classifySession } from '../actions/classify-session.js';
+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,
+};
+const mockSession = {
+    id: 'session-123',
+    recording: {
+        id: 'rec-123',
+        source: {
+            type: 'cap',
+            originalPath: '/test/path',
+        },
+        videoPath: '/test/video.mp4',
+        audioMicPath: '/test/audio.mp3',
+        audioSystemPath: null,
+        duration: 10,
+        capturedAt: new Date('2026-01-08'),
+    },
+    transcripts: [
+        {
+            source: 'mic',
+            transcript: mockTranscript,
+        },
+    ],
+    visualLogs: [],
+    segments: [],
+    status: 'transcribed',
+    classification: null,
+    metadata: null,
+    artifacts: [],
+    createdAt: new Date('2026-01-08'),
+    updatedAt: new Date('2026-01-08'),
+};
+const mockClassificationResult = {
+    meeting: 10,
+    debugging: 90,
+    tutorial: 15,
+    learning: 20,
+    working: 5,
+};
+const mockClassify = vi.fn();
+const mockExtractMetadata = vi.fn().mockResolvedValue({
+    speakers: [],
+    keyMoments: [],
+    actionItems: [],
+    technicalTerms: [],
+    codeSnippets: [],
+});
+const mockGenerate = vi.fn();
+const mockIntelligence = {
+    classify: mockClassify,
+    classifySegment: vi.fn(),
+    extractMetadata: mockExtractMetadata,
+    generate: mockGenerate,
+    describeImages: vi.fn(),
+    embedText: vi.fn(),
+    extractTopics: vi.fn(),
+    generateText: vi.fn().mockResolvedValue('Mock generated text'),
+};
+describe('classifySession', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        mockClassify.mockResolvedValue(mockClassificationResult);
+    });
+    it('should throw error without transcripts', async () => {
+        const sessionWithoutTranscripts = { ...mockSession, transcripts: [] };
+        await expect(classifySession(sessionWithoutTranscripts, mockIntelligence)).rejects.toThrow('Cannot classify session without transcripts');
+    });
+    it('should classify session and update status', async () => {
+        const result = await classifySession(mockSession, mockIntelligence);
+        expect(result.status).toBe('classified');
+        expect(result.classification).toBeDefined();
+        if (result.classification) {
+            expect(result.classification.debugging).toBe(90);
+            expect(result.classification.meeting).toBe(10);
+        }
+    });
+    it('should not mutate original session', async () => {
+        const originalStatus = mockSession.status;
+        const originalUpdatedAt = mockSession.updatedAt;
+        await classifySession(mockSession, mockIntelligence);
+        expect(mockSession.status).toBe(originalStatus);
+        expect(mockSession.updatedAt).toBe(originalUpdatedAt);
+    });
+    it('should call intelligence.classify with transcript', async () => {
+        await classifySession(mockSession, mockIntelligence);
+        expect(mockClassify).toHaveBeenCalled();
+        // Since we only have one transcript, it should be called with the original
+        expect(mockClassify).toHaveBeenCalledWith(mockTranscript, []);
+    });
+    it('should interleave multiple transcripts', async () => {
+        const sessionWithMultipleTranscripts = {
+            ...mockSession,
+            transcripts: [
+                { source: 'mic', transcript: mockTranscript },
+                {
+                    source: 'system',
+                    transcript: {
+                        ...mockTranscript,
+                        segments: [
+                            {
+                                id: 'seg-sys-0',
+                                start: 3,
+                                end: 4,
+                                text: 'Error notification sound',
+                            },
+                        ],
+                        fullText: 'Error notification sound',
+                    },
+                },
+            ],
+        };
+        await classifySession(sessionWithMultipleTranscripts, mockIntelligence);
+        expect(mockClassify).toHaveBeenCalled();
+        const calledWith = mockClassify.mock.calls[0][0];
+        // Should have interleaved the transcripts
+        expect(calledWith.fullText).toContain('[00:00 MIC]');
+        expect(calledWith.fullText).toContain('[00:03 SYSTEM]');
+    });
+});