@hasna/microservices 0.0.2 → 0.0.4

package/microservices/microservice-transcriber/src/lib/live.ts

@@ -0,0 +1,94 @@
+/**
+ * Live/streaming transcription — record from microphone via ffmpeg,
+ * chunk into segments, transcribe each as they complete.
+ */
+
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { TranscribeOptions } from "./providers.js";
+import { transcribeFile } from "./providers.js";
+
+export interface LiveTranscribeOptions extends TranscribeOptions {
+  chunkDurationSec?: number; // seconds per chunk (default: 30)
+  onChunk?: (text: string, chunkIndex: number) => void;
+  onError?: (error: Error, chunkIndex: number) => void;
+}
+
+/**
+ * Record from default audio input and transcribe in real-time.
+ * Returns a controller to stop recording.
+ *
+ * Uses ffmpeg with avfoundation (macOS) or alsa/pulse (Linux).
+ * Each chunk is saved, transcribed, then deleted.
+ */
+export function startLiveTranscription(options: LiveTranscribeOptions = {}): {
+  stop: () => Promise<{ fullText: string; chunks: string[] }>;
+} {
+  const chunkDuration = options.chunkDurationSec ?? 30;
+  const sessionId = crypto.randomUUID().slice(0, 8);
+  const chunks: string[] = [];
+  let chunkIndex = 0;
+  let stopped = false;
+  let currentProc: ReturnType<typeof Bun.spawn> | null = null;
+  let resolveStop: ((value: { fullText: string; chunks: string[] }) => void) | null = null;
+
+  const processChunk = async (chunkPath: string, idx: number) => {
+    if (!existsSync(chunkPath)) return;
+    try {
+      const result = await transcribeFile(chunkPath, {
+        provider: options.provider,
+        language: options.language,
+        diarize: options.diarize,
+      });
+      chunks.push(result.text);
+      options.onChunk?.(result.text, idx);
+    } catch (err) {
+      options.onError?.(err instanceof Error ? err : new Error(String(err)), idx);
+    } finally {
+      try { unlinkSync(chunkPath); } catch {}
+    }
+  };
+
+  const recordLoop = async () => {
+    while (!stopped) {
+      const chunkPath = join(tmpdir(), `live-${sessionId}-${chunkIndex}.wav`);
+      const idx = chunkIndex++;
+
+      // Detect platform for audio input
+      const isLinux = process.platform === "linux";
+      const inputArgs = isLinux
+        ? ["-f", "pulse", "-i", "default"]
+        : ["-f", "avfoundation", "-i", ":0"]; // macOS default mic
+
+      currentProc = Bun.spawn(
+        ["ffmpeg", "-y", ...inputArgs, "-t", String(chunkDuration), "-ac", "1", "-ar", "16000", chunkPath],
+        { stdout: "pipe", stderr: "pipe" }
+      );
+
+      await currentProc.exited;
+      currentProc = null;
+
+      if (stopped && !existsSync(chunkPath)) break;
+
+      // Transcribe the chunk (don't await — let it process while next chunk records)
+      processChunk(chunkPath, idx);
+    }
+
+    // Wait for any pending transcriptions to settle
+    await new Promise((r) => setTimeout(r, 500));
+    resolveStop?.({ fullText: chunks.join(" "), chunks });
+  };
+
+  // Start recording in background
+  recordLoop();
+
+  return {
+    stop: () => {
+      stopped = true;
+      // Kill current ffmpeg recording
+      try { currentProc?.kill(); } catch {}
+      return new Promise((resolve) => { resolveStop = resolve; });
+    },
+  };
+}

package/microservices/microservice-transcriber/src/lib/notion.ts

@@ -0,0 +1,129 @@
+/**
+ * Notion export — pushes a transcript to a Notion page as blocks.
+ * Uses the Notion API directly (no SDK dependency needed).
+ * Requires NOTION_API_KEY and a target page/database ID.
+ */
+
+import type { Transcript } from "../db/transcripts.js";
+
+const NOTION_API = "https://api.notion.com/v1";
+const NOTION_VERSION = "2022-06-28";
+
+function getNotionHeaders(): Record<string, string> {
+  const key = process.env["NOTION_API_KEY"];
+  if (!key) throw new Error("NOTION_API_KEY is not set. Create an integration at https://www.notion.so/my-integrations");
+  return {
+    Authorization: `Bearer ${key}`,
+    "Notion-Version": NOTION_VERSION,
+    "Content-Type": "application/json",
+  };
+}
+
+/**
+ * Create a new Notion page under a parent page with the transcript content.
+ */
+export async function pushToNotion(
+  transcript: Transcript,
+  parentPageId: string
+): Promise<{ pageId: string; url: string }> {
+  const blocks = buildNotionBlocks(transcript);
+
+  const res = await fetch(`${NOTION_API}/pages`, {
+    method: "POST",
+    headers: getNotionHeaders(),
+    body: JSON.stringify({
+      parent: { page_id: parentPageId },
+      properties: {
+        title: {
+          title: [{ text: { content: transcript.title ?? "Transcript" } }],
+        },
+      },
+      children: blocks.slice(0, 100), // Notion limit: 100 blocks per request
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Notion API error ${res.status}: ${body}`);
+  }
+
+  const data = (await res.json()) as { id: string; url: string };
+
+  // Append remaining blocks if >100
+  if (blocks.length > 100) {
+    for (let i = 100; i < blocks.length; i += 100) {
+      await fetch(`${NOTION_API}/blocks/${data.id}/children`, {
+        method: "PATCH",
+        headers: getNotionHeaders(),
+        body: JSON.stringify({ children: blocks.slice(i, i + 100) }),
+      });
+    }
+  }
+
+  return { pageId: data.id, url: data.url };
+}
+
+function buildNotionBlocks(t: Transcript): Array<Record<string, unknown>> {
+  const blocks: Array<Record<string, unknown>> = [];
+
+  // Metadata callout
+  const meta = [
+    t.provider && `Provider: ${t.provider}`,
+    t.duration_seconds && `Duration: ${Math.floor(t.duration_seconds / 60)}m ${Math.floor(t.duration_seconds % 60)}s`,
+    t.word_count && `Words: ${t.word_count}`,
+    t.source_url && `Source: ${t.source_url}`,
+  ].filter(Boolean).join(" | ");
+
+  if (meta) {
+    blocks.push({
+      object: "block",
+      type: "callout",
+      callout: {
+        icon: { emoji: "🎙️" },
+        rich_text: [{ type: "text", text: { content: meta } }],
+      },
+    });
+  }
+
+  // Summary
+  if (t.metadata?.summary) {
+    blocks.push(heading("Summary", 2));
+    blocks.push(paragraph(t.metadata.summary));
+  }
+
+  // Chapters or plain text
+  if (t.metadata?.chapters && t.metadata.chapters.length > 0) {
+    for (const ch of t.metadata.chapters) {
+      blocks.push(heading(ch.title, 2));
+      // Split long text into 2000-char chunks (Notion block text limit)
+      for (const chunk of splitText(ch.text, 2000)) {
+        blocks.push(paragraph(chunk));
+      }
+    }
+  } else if (t.transcript_text) {
+    blocks.push(heading("Transcript", 2));
+    for (const chunk of splitText(t.transcript_text, 2000)) {
+      blocks.push(paragraph(chunk));
+    }
+  }
+
+  return blocks;
+}
+
+function heading(text: string, level: 2 | 3): Record<string, unknown> {
+  const key = `heading_${level}`;
+  return { object: "block", type: key, [key]: { rich_text: [{ type: "text", text: { content: text } }] } };
+}
+
+function paragraph(text: string): Record<string, unknown> {
+  return { object: "block", type: "paragraph", paragraph: { rich_text: [{ type: "text", text: { content: text } }] } };
+}
+
+function splitText(text: string, maxLen: number): string[] {
+  if (text.length <= maxLen) return [text];
+  const chunks: string[] = [];
+  for (let i = 0; i < text.length; i += maxLen) {
+    chunks.push(text.slice(i, i + maxLen));
+  }
+  return chunks;
+}