escribano 0.1.0

package/dist/adapters/publishing.outline.adapter.js

@@ -0,0 +1,75 @@
+/**
+ * Escribano - Outline Publishing Adapter
+ *
+ * Implements PublishingService for Outline wiki.
+ */
+export function createOutlinePublishingService(config) {
+    const baseUrl = config.url.replace(/\/$/, '');
+    async function apiCall(endpoint, body) {
+        const response = await fetch(`${baseUrl}/api/${endpoint}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(`Outline API error: ${response.status} ${JSON.stringify(data)}`);
+        }
+        return data;
+    }
+    return {
+        async ensureCollection(name) {
+            const list = await apiCall('collections.list', {});
+            const existing = list.data.find((c) => c.name === name);
+            if (existing) {
+                return { id: existing.id };
+            }
+            const created = await apiCall('collections.create', { name });
+            return { id: created.data.id };
+        },
+        async createDocument(params) {
+            const result = await apiCall('documents.create', {
+                collectionId: params.collectionId,
+                parentDocumentId: params.parentDocumentId,
+                title: params.title,
+                text: params.content,
+                publish: params.publish ?? true,
+            });
+            return {
+                id: result.data.id,
+                url: `${baseUrl}/doc/${result.data.id}`,
+            };
+        },
+        async updateDocument(id, params) {
+            await apiCall('documents.update', {
+                id,
+                title: params.title,
+                text: params.content,
+            });
+        },
+        async findDocumentByTitle(collectionId, title) {
+            // Note: Outline search or list could be used. list is safer for exact title match in collection.
+            const list = await apiCall('documents.list', { collectionId });
+            const doc = list.data.find((d) => d.title === title);
+            if (doc) {
+                return {
+                    id: doc.id,
+                    url: `${baseUrl}/doc/${doc.id}`,
+                };
+            }
+            return null;
+        },
+        async listDocuments(collectionId) {
+            const list = await apiCall('documents.list', { collectionId });
+            return list.data.map((d) => ({
+                id: d.id,
+                title: d.title,
+                parentDocumentId: d.parentDocumentId,
+                url: `${baseUrl}/doc/${d.id}`,
+            }));
+        },
+    };
+}

package/dist/adapters/storage.adapter.js

@@ -0,0 +1,81 @@
+/**
+ * Escribano - Storage Adapter
+ *
+ * Saves and loads sessions from filesystem
+ */
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import { join } from 'node:path';
+const SESSIONS_DIR = join(os.homedir(), '.escribano', 'sessions');
+export function createStorageService() {
+    return {
+        saveSession,
+        loadSession,
+        listSessions,
+        saveArtifact,
+        loadArtifacts,
+    };
+}
+async function ensureSessionsDir() {
+    await mkdir(SESSIONS_DIR, { recursive: true });
+}
+async function saveSession(session) {
+    await ensureSessionsDir();
+    const sessionPath = join(SESSIONS_DIR, `${session.id}.json`);
+    await writeFile(sessionPath, JSON.stringify(session, null, 2), 'utf-8');
+}
+async function loadSession(sessionId) {
+    await ensureSessionsDir();
+    const sessionPath = join(SESSIONS_DIR, `${sessionId}.json`);
+    try {
+        const content = await readFile(sessionPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function listSessions() {
+    await ensureSessionsDir();
+    const files = await readdir(SESSIONS_DIR);
+    const jsonFiles = files.filter((file) => file.endsWith('.json'));
+    const sessions = [];
+    for (const file of jsonFiles) {
+        const content = await readFile(join(SESSIONS_DIR, file), 'utf-8');
+        sessions.push(JSON.parse(content));
+    }
+    return sessions;
+}
+async function saveArtifact(sessionId, artifact) {
+    const artifactsDir = join(SESSIONS_DIR, sessionId, 'artifacts');
+    await mkdir(artifactsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0];
+    const filename = `${artifact.type}-${timestamp}.${artifact.format}`;
+    const artifactPath = join(artifactsDir, filename);
+    await writeFile(artifactPath, artifact.content, 'utf-8');
+}
+async function loadArtifacts(sessionId) {
+    const artifactsDir = join(SESSIONS_DIR, sessionId, 'artifacts');
+    try {
+        const files = await readdir(artifactsDir);
+        const artifacts = [];
+        for (const file of files) {
+            const content = await readFile(join(artifactsDir, file), 'utf-8');
+            const match = file.match(/^(\w+)-(.+)\.md$/);
+            if (!match)
+                continue;
+            const [, type] = match;
+            artifacts.push({
+                id: `${sessionId}-${file.replace('.md', '')}`,
+                type: type,
+                content,
+                format: 'markdown',
+                createdAt: new Date(),
+            });
+        }
+        return artifacts;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/adapters/storage.fs.adapter.js

@@ -0,0 +1,83 @@
+/**
+ * Escribano - Storage Adapter
+ *
+ * Saves and loads sessions from filesystem
+ */
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import { join } from 'node:path';
+const SESSIONS_DIR = join(os.homedir(), '.escribano', 'sessions');
+export function createFsStorageService() {
+    return {
+        saveSession,
+        loadSession,
+        listSessions,
+        saveArtifact,
+        loadArtifacts,
+    };
+}
+async function ensureSessionsDir() {
+    await mkdir(SESSIONS_DIR, { recursive: true });
+}
+async function saveSession(session) {
+    await ensureSessionsDir();
+    const sessionPath = join(SESSIONS_DIR, `${session.id}.json`);
+    await writeFile(sessionPath, JSON.stringify(session, null, 2), 'utf-8');
+}
+async function loadSession(sessionId) {
+    await ensureSessionsDir();
+    const sessionPath = join(SESSIONS_DIR, `${sessionId}.json`);
+    try {
+        const content = await readFile(sessionPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function listSessions() {
+    await ensureSessionsDir();
+    const files = await readdir(SESSIONS_DIR);
+    const jsonFiles = files.filter((file) => file.endsWith('.json'));
+    const sessions = [];
+    for (const file of jsonFiles) {
+        const content = await readFile(join(SESSIONS_DIR, file), 'utf-8');
+        sessions.push(JSON.parse(content));
+    }
+    // Sort by date descending (newest first)
+    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+async function saveArtifact(sessionId, artifact) {
+    const artifactsDir = join(SESSIONS_DIR, sessionId, 'artifacts');
+    await mkdir(artifactsDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0];
+    const extension = artifact.format === 'markdown' ? 'md' : artifact.format;
+    const filename = `${artifact.type}-${timestamp}.${extension}`;
+    const artifactPath = join(artifactsDir, filename);
+    await writeFile(artifactPath, artifact.content, 'utf-8');
+}
+async function loadArtifacts(sessionId) {
+    const artifactsDir = join(SESSIONS_DIR, sessionId, 'artifacts');
+    try {
+        const files = await readdir(artifactsDir);
+        const artifacts = [];
+        for (const file of files) {
+            const content = await readFile(join(artifactsDir, file), 'utf-8');
+            const match = file.match(/^(\w+)-(.+)\.md$/);
+            if (!match)
+                continue;
+            const [, type] = match;
+            artifacts.push({
+                id: `${sessionId}-${file.replace('.md', '')}`,
+                type: type,
+                content,
+                format: 'markdown',
+                createdAt: new Date(),
+            });
+        }
+        return artifacts;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/adapters/transcription.whisper.adapter.js

@@ -0,0 +1,206 @@
+/**
+ * Whisper Adapter
+ *
+ * Transcribes audio using whisper.cpp or OpenAI's whisper CLI.
+ * Shells out to the whisper binary for simplicity.
+ *
+ * Prerequisites:
+ * - whisper.cpp installed: brew install whisper-cpp
+ * - ffmpeg installed: brew install ffmpeg (for audio format conversion)
+ * - Or Python whisper: pip install openai-whisper
+ */
+import { exec } from 'node:child_process';
+import { readFile, unlink } from 'node:fs/promises';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+const HALLUCINATION_PATTERNS = [
+    /untertitel.*amara\.org/i,
+    /www\.amara\.org/i,
+    /thanks for watching/i,
+    /please subscribe/i,
+    /like and subscribe/i,
+    /(.{20,})\1{4,}/, // Repetition loops
+];
+export function filterHallucinations(text) {
+    let filtered = text;
+    for (const pattern of HALLUCINATION_PATTERNS) {
+        filtered = filtered.replace(pattern, '');
+    }
+    return filtered.trim();
+}
+async function convertToWavIfNeeded(audioPath) {
+    const ext = audioPath.toLowerCase().split('.').pop();
+    if (['wav', 'flac', 'mp3'].includes(ext || '')) {
+        return audioPath;
+    }
+    const outputPath = `${audioPath}.converted.wav`;
+    try {
+        console.log(`Converting ${audioPath} to WAV format...`);
+        await execAsync(`ffmpeg -i "${audioPath}" -f wav -ar 16000 -ac 1 "${outputPath}" -y`, { timeout: 10 * 60 * 1000 });
+        console.log(`Conversion complete: ${outputPath}`);
+        return outputPath;
+    }
+    catch (error) {
+        console.error(`Audio conversion failed for ${audioPath}`);
+        throw new Error(`Failed to convert audio to WAV: ${error.message}`);
+    }
+}
+/**
+ * Creates a TranscriptionService that uses whisper CLI
+ */
+export function createWhisperTranscriptionService(config = {}) {
+    const resolvedConfig = {
+        binaryPath: config.binaryPath ?? 'whisper-cpp',
+        model: config.model ?? 'base',
+        outputFormat: config.outputFormat ?? 'json',
+        language: config.language,
+    };
+    return {
+        transcribe: (audioPath) => transcribeWithWhisper(audioPath, resolvedConfig),
+        transcribeSegment: async (audioPath) => {
+            try {
+                const transcript = await transcribeWithWhisper(audioPath, resolvedConfig, { silent: true });
+                if (!transcript || !transcript.fullText) {
+                    return '';
+                }
+                return filterHallucinations(transcript.fullText);
+            }
+            catch (error) {
+                console.warn(`Whisper segment transcription failed: ${error.message}`);
+                return '';
+            }
+        },
+    };
+}
+/**
+ * Transcribe audio file using whisper CLI
+ */
+async function transcribeWithWhisper(audioPath, config, options) {
+    const audioToProcess = await convertToWavIfNeeded(audioPath);
+    const args = [
+        `-m ${config.model}`,
+        `-f "${audioToProcess}"`,
+        '-oj', // Output JSON
+        config.language ? `-l ${config.language}` : '',
+    ].filter(Boolean);
+    const command = `${config.binaryPath} ${args.join(' ')}`;
+    try {
+        let tick;
+        if (!options?.silent) {
+            tick = setInterval(() => {
+                process.stdout.write('.');
+            }, 30000); // Print a dot every 30 seconds to indicate progress
+        }
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: config.cwd,
+            maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large transcripts
+            timeout: 10 * 60 * 1000, // 10 minute timeout
+        });
+        if (tick) {
+            clearInterval(tick);
+            process.stdout.write('\n');
+        }
+        const hasError = stderr.includes('error:') ||
+            stderr.includes('Error:') ||
+            stderr.includes('failed to');
+        if (hasError) {
+            if (audioToProcess !== audioPath) {
+                await unlink(audioToProcess).catch(() => { });
+            }
+            throw new Error(`Whisper transcription failed:\n${stderr}`);
+        }
+        // whisper-cpp outputs JSON to a file named <input>.json
+        const jsonOutputPath = `${audioToProcess}.json`;
+        try {
+            const jsonContent = await readFile(jsonOutputPath, 'utf-8');
+            const whisperOutput = JSON.parse(jsonContent);
+            // Clean up the temp JSON file and converted audio
+            await unlink(jsonOutputPath).catch(() => { });
+            if (audioToProcess !== audioPath) {
+                await unlink(audioToProcess).catch(() => { });
+            }
+            return parseWhisperOutput(whisperOutput);
+        }
+        catch {
+            // Fallback: try to parse stdout as the transcript
+            return parseWhisperStdout(stdout);
+        }
+    }
+    catch (error) {
+        if (audioToProcess && audioToProcess !== audioPath) {
+            await unlink(audioToProcess).catch(() => { });
+        }
+        throw new Error(`Whisper transcription failed: ${error.message}`);
+    }
+}
+/**
+ * Parse whisper.cpp JSON output into our Transcript format
+ */
+function parseWhisperOutput(output) {
+    const segments = output.transcription.map((seg, index) => ({
+        id: `seg-${index}`,
+        start: seg.offsets.from / 1000, // Convert ms to seconds
+        end: seg.offsets.to / 1000,
+        text: seg.text.trim(),
+        speaker: null,
+    }));
+    const fullText = segments.map((s) => s.text).join(' ');
+    const duration = segments.length > 0 ? segments[segments.length - 1].end : 0;
+    return {
+        fullText,
+        segments,
+        language: 'en', // whisper.cpp doesn't always report language in JSON
+        duration,
+    };
+}
+/**
+ * Fallback: parse whisper stdout (plain text with timestamps)
+ */
+function parseWhisperStdout(stdout) {
+    // Example format: "[00:00:00.000 --> 00:00:05.000] Hello world"
+    const lines = stdout.split('\n').filter((l) => l.trim());
+    const segments = [];
+    const timestampRegex = /\[(\d{2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}\.\d{3})\]\s*(.*)/;
+    for (const line of lines) {
+        const match = line.match(timestampRegex);
+        if (match) {
+            const [, startStr, endStr, text] = match;
+            segments.push({
+                id: `seg-${segments.length}`,
+                start: parseTimestamp(startStr),
+                end: parseTimestamp(endStr),
+                text: text.trim(),
+                speaker: null,
+            });
+        }
+    }
+    // If no timestamps found, treat entire output as single segment
+    if (segments.length === 0 && stdout.trim()) {
+        segments.push({
+            id: 'seg-0',
+            start: 0,
+            end: 0,
+            text: stdout.trim(),
+            speaker: null,
+        });
+    }
+    const fullText = segments.map((s) => s.text).join(' ');
+    const duration = segments.length > 0 ? segments[segments.length - 1].end : 0;
+    return {
+        fullText,
+        segments,
+        language: 'en',
+        duration,
+    };
+}
+/**
+ * Parse timestamp string "00:00:00.000" to seconds
+ */
+function parseTimestamp(timestamp) {
+    const [hours, minutes, rest] = timestamp.split(':');
+    const [seconds, ms] = rest.split('.');
+    return (parseInt(hours, 10) * 3600 +
+        parseInt(minutes, 10) * 60 +
+        parseInt(seconds, 10) +
+        parseInt(ms, 10) / 1000);
+}