escribano 0.4.5 → 0.5.0

package/dist/python-utils.js

@@ -10,6 +10,16 @@ import { resolve } from 'node:path';
 export const ESCRIBANO_HOME = resolve(homedir(), '.escribano');
 export const ESCRIBANO_VENV = resolve(ESCRIBANO_HOME, 'venv');
 export const ESCRIBANO_VENV_PYTHON = resolve(ESCRIBANO_VENV, 'bin', 'python3');
+/**
+ * Check if a path is inside the current working directory (project-local).
+ * Used to skip VIRTUAL_ENV/UV_PROJECT_ENVIRONMENT that are dev venvs for
+ * the project itself, not suitable as Escribano's Python runtime.
+ */
+function isInsideCwd(path) {
+    const absPath = resolve(path);
+    const cwd = process.cwd();
+    return absPath.startsWith(`${cwd}/`) || absPath.startsWith(`${cwd}\\`);
+}
 /**
  * Get explicitly configured Python path.
  * Returns null when nothing is explicitly configured or found via well-known
@@ -19,29 +29,37 @@ export const ESCRIBANO_VENV_PYTHON = resolve(ESCRIBANO_VENV, 'bin', 'python3');
  *
  * Priority:
  * 1. ESCRIBANO_PYTHON_PATH env var (explicit override)
- * 2. Active virtual environment (VIRTUAL_ENV)
- * 3. UV_PROJECT_ENVIRONMENT (uv project-synced venv)
- * 4. Project-local .venv (created by `uv venv` in CWD)
- * 5. ~/.venv/bin/python3 (home-level venv)
- * 6. null — no environment detected; auto-venv will be created
+ * 2. ~/.escribano/venv (managed venv, if it exists — preferred once created)
+ * 3. Active virtual environment (VIRTUAL_ENV, unless inside CWD)
+ * 4. UV_PROJECT_ENVIRONMENT (uv project-synced venv, unless inside CWD)
+ * 5. Project-local .venv (created by `uv venv` in CWD)
+ * 6. ~/.venv/bin/python3 (home-level venv)
+ * 7. null — no environment detected; auto-venv will be created
  */
 export function getPythonPath() {
+    // 1. Explicit override always wins
     if (process.env.ESCRIBANO_PYTHON_PATH) {
         return process.env.ESCRIBANO_PYTHON_PATH;
     }
-    if (process.env.VIRTUAL_ENV) {
+    // 2. Escribano's managed venv — preferred once it exists
+    if (existsSync(ESCRIBANO_VENV_PYTHON)) {
+        return ESCRIBANO_VENV_PYTHON;
+    }
+    // 3. Active virtual environment (skip if it's a project-local dev venv)
+    if (process.env.VIRTUAL_ENV && !isInsideCwd(process.env.VIRTUAL_ENV)) {
         return resolve(process.env.VIRTUAL_ENV, 'bin', 'python3');
     }
-    // UV_PROJECT_ENVIRONMENT: set by uv when running inside a project with `uv sync`
-    if (process.env.UV_PROJECT_ENVIRONMENT) {
+    // 4. UV_PROJECT_ENVIRONMENT (skip if inside CWD)
+    if (process.env.UV_PROJECT_ENVIRONMENT &&
+        !isInsideCwd(process.env.UV_PROJECT_ENVIRONMENT)) {
         return resolve(process.env.UV_PROJECT_ENVIRONMENT, 'bin', 'python3');
     }
-    // Check project-local .venv (created by `uv venv` in the current working directory)
+    // 5. Project-local .venv (created by `uv venv` in the current working directory)
     const localVenv = resolve(process.cwd(), '.venv', 'bin', 'python3');
     if (existsSync(localVenv)) {
         return localVenv;
     }
-    // Check common home-level venv (e.g., `uv venv ~/.venv`)
+    // 6. Home-level venv (e.g., `uv venv ~/.venv`)
     const uvHomeVenv = resolve(homedir(), '.venv', 'bin', 'python3');
     if (existsSync(uvHomeVenv)) {
         return uvHomeVenv;

package/dist/services/subject-grouping.js

@@ -7,6 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { step } from '../pipeline/context.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PERSONAL_APPS = new Set([
     'WhatsApp',
@@ -24,7 +25,7 @@ const PERSONAL_APPS = new Set([
     'Messages',
 ]);
 const PERSONAL_APP_THRESHOLD = 0.5;
-const SUBJECT_GROUPING_MODEL = process.env.ESCRIBANO_SUBJECT_GROUPING_MODEL || 'qwen3.5:27b';
+const SUBJECT_GROUPING_MODEL = process.env.ESCRIBANO_SUBJECT_GROUPING_MODEL;
 export async function groupTopicBlocksIntoSubjects(topicBlocks, intelligence, recordingId) {
     if (topicBlocks.length === 0) {
         return {
@@ -35,16 +36,42 @@ export async function groupTopicBlocksIntoSubjects(topicBlocks, intelligence, re
     }
     const blocksForGrouping = topicBlocks.map(extractBlockForGrouping);
     const prompt = buildGroupingPrompt(blocksForGrouping);
-    console.log(`[subject-grouping] Grouping ${topicBlocks.length} blocks into subjects (model: ${SUBJECT_GROUPING_MODEL})`);
+    const modelInfo = SUBJECT_GROUPING_MODEL
+        ? ` (model: ${SUBJECT_GROUPING_MODEL})`
+        : ' (auto-detected)';
+    console.log(`[subject-grouping] Grouping ${topicBlocks.length} blocks into subjects${modelInfo}`);
     try {
-        const response = await intelligence.generateText(prompt, {
-            expectJson: false,
-            model: SUBJECT_GROUPING_MODEL,
-            numPredict: 2000,
-            think: false,
+        const response = await step('llm_subject_grouping', async () => {
+            return intelligence.generateText(prompt, {
+                expectJson: false,
+                model: SUBJECT_GROUPING_MODEL || undefined,
+                numPredict: 2000,
+                think: false,
+                debugContext: {
+                    recordingId,
+                    callType: 'subject_grouping',
+                },
+            });
         });
-        console.log(`[subject-grouping] LLM response (${response.length} chars):\n${response.slice(0, 500)}${response.length > 500 ? '...' : ''}`);
-        const grouping = parseGroupingResponse(response, topicBlocks);
+        // Strip thinking leakage if present
+        let cleaned = response.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        if (cleaned.includes('</think>')) {
+            // Handle orphan </think> tag (Qwen3.5 behavior)
+            cleaned = cleaned.split('</think>')[1].trim();
+        }
+        // Strip "Thinking Process:" prose (Qwen3.5-OptiQ format)
+        const tpMatch = cleaned.match(/(?:^|\n)Thinking Process:/);
+        if (tpMatch !== null) {
+            const after = cleaned.slice((tpMatch.index ?? 0) + tpMatch[0].length);
+            const heading = after.match(/\n(#\s|\*\*|Group\s)/);
+            cleaned =
+                heading?.index !== undefined ? after.slice(heading.index).trim() : '';
+        }
+        if (cleaned.length < 10) {
+            console.warn('[subject-grouping] Thinking leakage detected or response too short — parseGroupingResponse will fall back');
+        }
+        console.log(`[subject-grouping] LLM response (${cleaned.length} chars after stripping):\n${cleaned.slice(0, 500)}${cleaned.length > 500 ? '...' : ''}`);
+        const grouping = parseGroupingResponse(cleaned || response, topicBlocks);
         console.log(`[subject-grouping] Parsed ${grouping.groups.length} groups: ${grouping.groups.map((g) => g.label).join(', ')}`);
         const subjects = grouping.groups.map((group, index) => {
             const subjectId = `subject-${recordingId}-${index}`;

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/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.mlx.adapter.test.js

@@ -22,7 +22,7 @@ vi.mock('node:child_process', () => ({
         kill: vi.fn(),
     })),
 }));
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { resolvePythonPath } from '../adapters/intelligence.mlx.adapter.js';
 import { getPythonPath } from '../python-utils.js';
 const mockExistsSync = vi.mocked(existsSync);
@@ -178,8 +178,10 @@ describe('resolvePythonPath', () => {
     });
     it('installs mlx-vlm when the import probe fails', async () => {
         const venvPython = resolve(homedir(), '.escribano', 'venv', 'bin', 'python3');
-        // Simulate: managed venv python exists
-        mockExistsSync.mockImplementation((p) => p === venvPython);
+        const escribanoHome = resolve(homedir(), '.escribano');
+        mockExistsSync.mockImplementation((p) => p === escribanoHome);
+        const mockMkdirSync = vi.mocked(mkdirSync);
+        mockMkdirSync.mockReturnValue(undefined);
         const { spawn } = await import('node:child_process');
         const mockSpawn = vi.mocked(spawn);
         mockSpawn.mockClear();
@@ -189,9 +191,12 @@ describe('resolvePythonPath', () => {
             const emitter = {
                 on: vi.fn((event, cb) => {
                     if (event === 'exit') {
-                        // First call: import probe fails (non-zero exit)
-                        // All subsequent calls (ensurepip, pip install, ...): succeed
-                        cb(thisCall === 0 ? 1 : 0);
+                        if (thisCall === 1) {
+                            cb(1);
+                        }
+                        else {
+                            cb(0);
+                        }
                     }
                     return emitter;
                 }),
@@ -202,8 +207,7 @@ describe('resolvePythonPath', () => {
             return emitter;
         });
         await expect(resolvePythonPath()).resolves.toBe(venvPython);
-        expect(mockSpawn.mock.calls.length).toBeGreaterThanOrEqual(2);
-        // Find the pip install call regardless of its position (robust to ensurepip being inserted)
+        expect(mockSpawn.mock.calls.length).toBeGreaterThanOrEqual(3);
         const installCall = mockSpawn.mock.calls.find(([_cmd, args]) => Array.isArray(args) &&
             args.includes('-m') &&
             args.includes('pip') &&
@@ -217,6 +221,7 @@ describe('resolvePythonPath', () => {
             'mlx-vlm',
             'torch',
             'torchvision',
+            'mlx-lm',
         ]));
     });
 });