escribano 0.1.0

package/dist/actions/generate-summary-v3.js

@@ -0,0 +1,260 @@
+/**
+ * Escribano - Generate Summary V3
+ *
+ * Generates a work session summary from V3 processed TopicBlocks using LLM.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { log } from '../pipeline/context.js';
+/**
+ * Generate a work session summary artifact from processed TopicBlocks.
+ *
+ * @param recordingId - Recording ID to generate summary for
+ * @param repos - Database repositories
+ * @param intelligence - Intelligence service for LLM generation
+ * @param options - Generation options
+ * @returns Generated artifact
+ */
+export async function generateSummaryV3(recordingId, repos, intelligence, options) {
+    log('info', `[Summary V3] Generating summary for recording ${recordingId}...`);
+    // Get the recording
+    const recording = repos.recordings.findById(recordingId);
+    if (!recording) {
+        throw new Error(`Recording ${recordingId} not found`);
+    }
+    // Get TopicBlocks for this recording
+    const topicBlocks = repos.topicBlocks.findByRecording(recordingId);
+    if (topicBlocks.length === 0) {
+        throw new Error(`No TopicBlocks found for recording ${recordingId}. Run process-v3 first.`);
+    }
+    log('info', `[Summary V3] Found ${topicBlocks.length} TopicBlocks`);
+    // Build sections from TopicBlocks
+    const sections = [];
+    for (const block of topicBlocks) {
+        const classification = JSON.parse(block.classification || '{}');
+        sections.push({
+            activity: classification.activity_type || 'unknown',
+            duration: block.duration || classification.duration || 0,
+            description: classification.key_description || '',
+            transcript: classification.combined_transcript || '',
+            apps: classification.apps || [],
+            topics: classification.topics || [],
+            startTime: classification.start_time || 0,
+            endTime: classification.end_time || 0,
+        });
+    }
+    // Sort by start time
+    sections.sort((a, b) => a.startTime - b.startTime);
+    log('info', `[Summary V3] Building summary from ${sections.length} sections...`);
+    // Generate summary using LLM or template
+    let summaryContent;
+    const skipLlm = options.useTemplate || process.env.ESCRIBANO_SKIP_LLM === 'true';
+    if (skipLlm) {
+        log('info', '[Summary V3] Using template fallback (LLM skipped)');
+        summaryContent = formatSummary(sections, recording.duration, recording.id);
+    }
+    else {
+        log('info', '[Summary V3] Generating with LLM...');
+        summaryContent = await generateLlmSummary(sections, recording, intelligence);
+    }
+    // Ensure output directory exists
+    const outputDir = options.outputDir || path.join(homedir(), '.escribano', 'artifacts');
+    await mkdir(outputDir, { recursive: true });
+    // Generate filename
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const fileName = `${recordingId}-summary-${timestamp}.md`;
+    const filePath = path.join(outputDir, fileName);
+    // Write to file
+    await writeFile(filePath, summaryContent, 'utf-8');
+    log('info', `[Summary V3] Summary saved to: ${filePath}`);
+    return {
+        id: `summary-${recordingId}-${Date.now()}`,
+        recordingId,
+        content: summaryContent,
+        filePath,
+        createdAt: new Date(),
+    };
+}
+/**
+ * Generate summary using LLM.
+ */
+async function generateLlmSummary(sections, recording, intelligence) {
+    // Read prompt template
+    const promptPath = path.join(process.cwd(), 'prompts', 'summary-v3.md');
+    let promptTemplate;
+    try {
+        promptTemplate = await readFile(promptPath, 'utf-8');
+    }
+    catch {
+        // Fallback if prompt file not found
+        log('warn', '[Summary V3] Prompt template not found, using default');
+        promptTemplate = `Generate a summary of this work session.\n\nSession Duration: {{SESSION_DURATION}} minutes\nActivities: {{ACTIVITY_COUNT}}\n\n{{ACTIVITY_TIMELINE}}`;
+    }
+    // Extract unique apps from all sections
+    const allApps = new Set();
+    for (const section of sections) {
+        for (const app of section.apps) {
+            allApps.add(app);
+        }
+    }
+    const appsList = [...allApps].sort().join(', ') || 'None detected';
+    // Extract URLs from all descriptions
+    const urlPattern = /https?:\/\/[^\s<>"{}|\\^`[\]]+/gi;
+    const allUrls = new Set();
+    for (const section of sections) {
+        const matches = section.description.match(urlPattern);
+        if (matches) {
+            for (const url of matches) {
+                // Clean up trailing punctuation
+                const cleanUrl = url.replace(/[.,;:!?)\]]+$/, '');
+                allUrls.add(cleanUrl);
+            }
+        }
+        // Also check transcripts for URLs
+        const transcriptMatches = section.transcript.match(urlPattern);
+        if (transcriptMatches) {
+            for (const url of transcriptMatches) {
+                const cleanUrl = url.replace(/[.,;:!?)\]]+$/, '');
+                allUrls.add(cleanUrl);
+            }
+        }
+    }
+    const urlsList = [...allUrls]
+        .sort()
+        .map((url) => `- ${url}`)
+        .join('\n') || 'None detected';
+    // Build activity timeline
+    const activityTimeline = sections
+        .map((section, i) => {
+        const startMin = Math.round(section.startTime / 60);
+        const durationMin = Math.round(section.duration / 60);
+        const startTimeStr = `${Math.floor(section.startTime / 60)}:${Math.floor(section.startTime % 60)
+            .toString()
+            .padStart(2, '0')}`;
+        const endTimeStr = `${Math.floor(section.endTime / 60)}:${Math.floor(section.endTime % 60)
+            .toString()
+            .padStart(2, '0')}`;
+        return `### Segment ${i + 1}: ${section.activity} (${startTimeStr} - ${endTimeStr}, ${durationMin} minutes)
+
+**Description:**
+${section.description || 'No description available'}
+
+**Apps:** ${section.apps.join(', ') || 'None detected'}
+**Topics:** ${section.topics.join(', ') || 'None detected'}
+
+${section.transcript ? `**Audio Transcript:**\n${section.transcript}` : '*No audio transcript*'}
+`;
+    })
+        .join('\n---\n\n');
+    // Replace template variables
+    const prompt = promptTemplate
+        .replace('{{SESSION_DURATION}}', String(Math.round(recording.duration / 60)))
+        .replace('{{SESSION_DATE}}', new Date(recording.captured_at).toLocaleDateString())
+        .replace('{{ACTIVITY_COUNT}}', String(sections.length))
+        .replace('{{ACTIVITY_TIMELINE}}', activityTimeline)
+        .replace('{{APPS_LIST}}', appsList)
+        .replace('{{URLS_LIST}}', urlsList);
+    // Call LLM
+    const result = await intelligence.generateText(prompt, {
+        expectJson: false,
+    });
+    return result;
+}
+/**
+ * Format sections into a readable markdown summary (template fallback).
+ */
+function formatSummary(sections, totalDuration, recordingId) {
+    const durationMinutes = Math.round(totalDuration / 60);
+    const now = new Date().toLocaleString();
+    // Extract unique apps from all sections
+    const allApps = new Set();
+    for (const section of sections) {
+        for (const app of section.apps) {
+            allApps.add(app);
+        }
+    }
+    const appsList = [...allApps].sort().join(', ') || 'None detected';
+    // Extract URLs from all descriptions
+    const urlPattern = /https?:\/\/[^\s<>"{}|\\^`[\]]+/gi;
+    const allUrls = new Set();
+    for (const section of sections) {
+        const matches = section.description.match(urlPattern);
+        if (matches) {
+            for (const url of matches) {
+                const cleanUrl = url.replace(/[.,;:!?)\]]+$/, '');
+                allUrls.add(cleanUrl);
+            }
+        }
+        const transcriptMatches = section.transcript.match(urlPattern);
+        if (transcriptMatches) {
+            for (const url of transcriptMatches) {
+                const cleanUrl = url.replace(/[.,;:!?)\]]+$/, '');
+                allUrls.add(cleanUrl);
+            }
+        }
+    }
+    const urlsList = [...allUrls]
+        .sort()
+        .map((url) => `- ${url}`)
+        .join('\n') || 'None detected';
+    let summary = `# Work Session Summary
+
+**Generated:** ${now}  
+**Recording ID:** ${recordingId}  
+**Session Duration:** ${durationMinutes} minutes  
+**Activities Identified:** ${sections.length}
+
+## Overview
+
+This work session consisted of ${sections.length} distinct activities over ${durationMinutes} minutes.
+
+## Apps & Pages Used
+
+### Applications
+${appsList}
+
+### Websites Visited
+${urlsList}
+
+`;
+    // Activity breakdown
+    summary += `## Activities
+
+`;
+    for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        const startMin = Math.round(section.startTime / 60);
+        const durationMin = Math.round(section.duration / 60);
+        summary += `### ${i + 1}. ${section.activity.charAt(0).toUpperCase() + section.activity.slice(1)}
+
+- **Time:** ${startMin} minutes into session
+- **Duration:** ${durationMin} minutes
+- **Apps:** ${section.apps.join(', ') || 'None detected'}
+- **Topics:** ${section.topics.join(', ') || 'None detected'}
+
+**What was happening:**
+${section.description || '*No visual description available*'}
+
+`;
+        if (section.transcript.trim()) {
+            summary += `**Audio transcript:**
+\`\`\`
+${section.transcript}
+\`\`\`
+
+`;
+        }
+        summary += `---
+
+`;
+    }
+    summary += `## Summary Statistics
+
+- Total activities: ${sections.length}
+- Total duration: ${durationMinutes} minutes
+- Activities with audio: ${sections.filter((s) => s.transcript.trim()).length}
+
+`;
+    return summary;
+}

package/dist/actions/outline-index.js

@@ -0,0 +1,204 @@
+/**
+ * Escribano - Outline Index Management
+ *
+ * Maintains a global session index document in Outline.
+ */
+import { log } from '../pipeline/context.js';
+/**
+ * Update the global session index in Outline.
+ *
+ * Creates or updates a master index document listing all published
+ * recording summaries with links to their respective documents.
+ *
+ * @param repos - Database repositories
+ * @param publishing - Outline publishing service
+ * @param options - Index options
+ * @returns URL of the index document
+ */
+export async function updateGlobalIndex(repos, publishing, options = {}) {
+    const collectionName = options.collectionName ?? 'Escribano Sessions';
+    const indexTitle = options.indexTitle ?? '📋 Session Summaries Index';
+    log('info', `[Index] Updating global index...`);
+    // 1. Ensure collection exists
+    const collection = await publishing.ensureCollection(collectionName);
+    // 2. Get all published recordings from DB
+    const recordings = repos.recordings.findByStatus('published');
+    // 3. Get topic blocks for all recordings
+    const recordingsWithBlocks = recordings.map((recording) => ({
+        recording,
+        blocks: repos.topicBlocks.findByRecording(recording.id),
+    }));
+    // 4. Build index content
+    const content = buildIndexContent(recordingsWithBlocks, indexTitle);
+    // 5. Check for existing index document
+    const existing = await publishing.findDocumentByTitle(collection.id, indexTitle);
+    // 6. Create or update index
+    let document;
+    if (existing) {
+        log('info', `[Index] Updating existing index`);
+        await publishing.updateDocument(existing.id, {
+            title: indexTitle,
+            content,
+        });
+        document = existing;
+    }
+    else {
+        log('info', `[Index] Creating new index`);
+        document = await publishing.createDocument({
+            collectionId: collection.id,
+            title: indexTitle,
+            content,
+            publish: true,
+        });
+    }
+    log('info', `[Index] Index updated: ${document.url}`);
+    return { url: document.url, documentId: document.id };
+}
+/**
+ * Build the index document content.
+ */
+function buildIndexContent(recordings, title) {
+    const now = new Date();
+    let content = `# ${title}\n\n`;
+    content += `*Last updated: ${now.toLocaleString()}*\n\n`;
+    // Group by month
+    const grouped = groupByMonth(recordings);
+    for (const [month, monthRecordings] of Object.entries(grouped)) {
+        content += `## ${month}\n\n`;
+        content += buildMonthTable(monthRecordings);
+        content += `\n`;
+    }
+    // Add summary stats
+    content += `\n---\n\n`;
+    content += `## Statistics\n\n`;
+    content += `- **Total sessions:** ${recordings.length}\n`;
+    content += `- **Total duration:** ${formatTotalDuration(recordings)}\n`;
+    content += `- **Last updated:** ${now.toLocaleString()}\n`;
+    return content;
+}
+/**
+ * Group recordings by month.
+ */
+function groupByMonth(recordings) {
+    const grouped = {};
+    for (const item of recordings) {
+        const date = new Date(item.recording.captured_at);
+        const month = date.toLocaleString('default', {
+            month: 'long',
+            year: 'numeric',
+        });
+        if (!grouped[month]) {
+            grouped[month] = [];
+        }
+        grouped[month].push(item);
+    }
+    // Sort months descending (newest first)
+    const sortedMonths = Object.keys(grouped).sort((a, b) => {
+        const dateA = new Date(grouped[a][0].recording.captured_at);
+        const dateB = new Date(grouped[b][0].recording.captured_at);
+        return dateB.getTime() - dateA.getTime();
+    });
+    const sorted = {};
+    for (const month of sortedMonths) {
+        sorted[month] = grouped[month];
+    }
+    return sorted;
+}
+/**
+ * Build a markdown table for a month's recordings.
+ */
+function buildMonthTable(recordings) {
+    // Sort by date descending
+    const sorted = [...recordings].sort((a, b) => {
+        const dateA = new Date(a.recording.captured_at).getTime();
+        const dateB = new Date(b.recording.captured_at).getTime();
+        return dateB - dateA;
+    });
+    let table = `| Date | Activities | Duration | Links |\n`;
+    table += `|------|------------|----------|-------|\n`;
+    for (const { recording, blocks } of sorted) {
+        const date = new Date(recording.captured_at);
+        const dateStr = date.toLocaleDateString();
+        const activities = extractActivities(blocks).slice(0, 3).join(', ') || 'Unknown';
+        const duration = formatDuration(recording.duration);
+        // Get all format variant links
+        const outlineUrls = extractOutlineUrls(recording);
+        let links = '—';
+        if (outlineUrls.length > 0) {
+            links = outlineUrls
+                .map((item) => `[${item.format}](${item.url})`)
+                .join(' · ');
+        }
+        table += `| ${dateStr} | ${activities} | ${duration} | ${links} |\n`;
+    }
+    return table;
+}
+/**
+ * Extract activities from topic blocks.
+ */
+function extractActivities(blocks) {
+    const activityCounts = new Map();
+    for (const block of blocks) {
+        try {
+            const classification = JSON.parse(block.classification || '{}');
+            const activity = classification.activity_type;
+            if (activity) {
+                activityCounts.set(activity, (activityCounts.get(activity) ?? 0) + 1);
+            }
+        }
+        catch {
+            // Ignore invalid JSON
+        }
+    }
+    return Array.from(activityCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([activity]) => activity.charAt(0).toUpperCase() + activity.slice(1));
+}
+/**
+ * Format duration in human-readable form.
+ */
+function formatDuration(seconds) {
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60) {
+        return `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (remainingMinutes === 0) {
+        return `${hours}h`;
+    }
+    return `${hours}h ${remainingMinutes}m`;
+}
+/**
+ * Calculate total duration of all recordings.
+ */
+function formatTotalDuration(recordings) {
+    const totalSeconds = recordings.reduce((sum, r) => sum + r.recording.duration, 0);
+    return formatDuration(totalSeconds);
+}
+/**
+ * Extract Outline URLs from recording metadata.
+ * Returns all format variants if available, otherwise the single outline URL.
+ */
+function extractOutlineUrls(recording) {
+    try {
+        const metadata = recording.source_metadata
+            ? JSON.parse(recording.source_metadata)
+            : {};
+        // Check for multiple format variants (new structure)
+        if (metadata.outline_formats && Array.isArray(metadata.outline_formats)) {
+            return metadata.outline_formats.map((item) => ({
+                format: item.format || 'unknown',
+                url: item.url || '',
+            }));
+        }
+        // Fallback to single outline URL (backward compatibility)
+        if (metadata.outline?.url) {
+            return [{ format: 'default', url: metadata.outline.url }];
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+}