@hasna/microservices 0.0.16 → 0.0.17

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

@@ -1,94 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/**
- * 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;
-}

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

@@ -1,296 +0,0 @@
-/**
- * AI-powered non-destructive spellcheck/proofread for transcripts.
- * Uses OpenAI or Anthropic to find spelling, grammar, punctuation, and clarity issues.
- * NEVER modifies transcript_text directly — issues are stored in proofread_issues table
- * and must be explicitly applied one by one.
- */
-
-import { getTranscript, updateTranscript } from "../db/transcripts.js";
-import {
-  createProofreadIssue,
-  listProofreadIssues,
-  getProofreadIssue,
-  updateIssueStatus,
-  getProofreadStats as getDbProofreadStats,
-  type ProofreadIssue,
-  type IssueType,
-  type IssueStatus,
-  type ListProofreadIssuesOptions,
-  type ProofreadStats,
-} from "../db/proofread.js";
-import { getDefaultSummaryProvider, type SummaryProvider } from "./summarizer.js";
-
-export type { ProofreadIssue, ProofreadStats, IssueType, IssueStatus };
-
-export interface ProofreadOptions {
-  types?: IssueType[];
-  confidence_threshold?: number;
-  provider?: SummaryProvider;
-}
-
-interface RawProofreadIssue {
-  issue_type: string;
-  position_start: number;
-  position_end: number;
-  original_text: string;
-  suggestion: string;
-  confidence: number;
-  explanation: string;
-}
-
-const PROOFREAD_PROMPT = (text: string, types?: IssueType[]) => {
-  const typeFilter = types && types.length > 0
-    ? `Only check for these issue types: ${types.join(", ")}.`
-    : "Check for all issue types: spelling, grammar, punctuation, clarity.";
-
-  return `You are a professional proofreader. Analyze the following transcript text and find all issues.
-
-${typeFilter}
-
-For each issue found, return a JSON object with:
-- "issue_type": one of "spelling", "grammar", "punctuation", "clarity"
-- "position_start": character index where the issue starts in the original text
-- "position_end": character index where the issue ends in the original text
-- "original_text": the exact text that has the issue
-- "suggestion": the corrected text
-- "confidence": a number 0-1 indicating how confident you are this is an issue
-- "explanation": brief explanation of the issue
-
-Return ONLY a valid JSON array of issue objects. If no issues found, return [].
-Do not wrap in markdown code fences.
-
-Transcript text:
-${text.slice(0, 15000)}`;
-};
-
-async function callOpenAI(prompt: string, maxTokens: number): Promise<string> {
-  const apiKey = process.env["OPENAI_API_KEY"];
-  if (!apiKey) throw new Error("OPENAI_API_KEY is not set");
-
-  const res = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model: "gpt-4o-mini",
-      messages: [{ role: "user", content: prompt }],
-      max_tokens: maxTokens,
-      temperature: 0.2,
-    }),
-  });
-
-  if (!res.ok) { const body = await res.text(); throw new Error(`OpenAI API error ${res.status}: ${body}`); }
-  const data = (await res.json()) as { choices: Array<{ message: { content: string } }> };
-  return data.choices[0]?.message?.content?.trim() ?? "";
-}
-
-async function callAnthropic(prompt: string, maxTokens: number): Promise<string> {
-  const apiKey = process.env["ANTHROPIC_API_KEY"];
-  if (!apiKey) throw new Error("ANTHROPIC_API_KEY is not set");
-
-  const res = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01", "Content-Type": "application/json" },
-    body: JSON.stringify({
-      model: "claude-haiku-4-5-20251001",
-      max_tokens: maxTokens,
-      messages: [{ role: "user", content: prompt }],
-    }),
-  });
-
-  if (!res.ok) { const body = await res.text(); throw new Error(`Anthropic API error ${res.status}: ${body}`); }
-  const data = (await res.json()) as { content: Array<{ type: string; text: string }> };
-  return data.content.find((b) => b.type === "text")?.text?.trim() ?? "";
-}
-
-function parseAIResponse(raw: string): RawProofreadIssue[] {
-  const cleaned = raw.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-  try {
-    const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(
-      (item: unknown) =>
-        typeof item === "object" &&
-        item !== null &&
-        "issue_type" in item &&
-        "original_text" in item
-    );
-  } catch {
-    return [];
-  }
-}
-
-const VALID_ISSUE_TYPES: Set<string> = new Set(["spelling", "grammar", "punctuation", "clarity"]);
-
-/**
- * Run AI proofreading on a transcript. Stores issues in DB. Never changes transcript_text.
- */
-export async function proofreadTranscript(
-  transcriptId: string,
-  options: ProofreadOptions = {}
-): Promise<ProofreadIssue[]> {
-  const transcript = getTranscript(transcriptId);
-  if (!transcript) throw new Error(`Transcript '${transcriptId}' not found.`);
-  if (!transcript.transcript_text) throw new Error(`Transcript '${transcriptId}' has no text.`);
-
-  const provider = options.provider ?? getDefaultSummaryProvider();
-  if (!provider) throw new Error("No AI provider configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY.");
-
-  const prompt = PROOFREAD_PROMPT(transcript.transcript_text, options.types);
-  const confidenceThreshold = options.confidence_threshold ?? 0.7;
-
-  let raw: string;
-  if (provider === "openai") {
-    raw = await callOpenAI(prompt, 3000);
-  } else {
-    raw = await callAnthropic(prompt, 3000);
-  }
-
-  const rawIssues = parseAIResponse(raw);
-  const created: ProofreadIssue[] = [];
-
-  for (const issue of rawIssues) {
-    // Validate issue_type
-    if (!VALID_ISSUE_TYPES.has(issue.issue_type)) continue;
-
-    // Filter by confidence threshold
-    const confidence = typeof issue.confidence === "number" ? issue.confidence : 0.8;
-    if (confidence < confidenceThreshold) continue;
-
-    // Filter by types if specified
-    if (options.types && options.types.length > 0 && !options.types.includes(issue.issue_type as IssueType)) continue;
-
-    const created_issue = createProofreadIssue({
-      transcript_id: transcriptId,
-      issue_type: issue.issue_type as IssueType,
-      position_start: typeof issue.position_start === "number" ? issue.position_start : undefined,
-      position_end: typeof issue.position_end === "number" ? issue.position_end : undefined,
-      original_text: String(issue.original_text),
-      suggestion: issue.suggestion ? String(issue.suggestion) : undefined,
-      confidence,
-      explanation: issue.explanation ? String(issue.explanation) : undefined,
-    });
-
-    created.push(created_issue);
-  }
-
-  return created;
-}
-
-/**
- * List proofread issues for a transcript with optional filters.
- */
-export function listIssues(
-  transcriptId: string,
-  filters?: ListProofreadIssuesOptions
-): ProofreadIssue[] {
-  return listProofreadIssues(transcriptId, filters);
-}
-
-/**
- * Apply a suggestion: replaces the original_text in transcript_text at the
- * specified position with the suggestion, and marks the issue as 'applied'.
- */
-export function applySuggestion(issueId: string): ProofreadIssue | null {
-  const issue = getProofreadIssue(issueId);
-  if (!issue) return null;
-  if (issue.status !== "pending") return issue; // already handled
-
-  if (!issue.suggestion) {
-    // No suggestion to apply, just dismiss
-    return updateIssueStatus(issueId, "dismissed");
-  }
-
-  const transcript = getTranscript(issue.transcript_id);
-  if (!transcript || !transcript.transcript_text) return null;
-
-  let newText: string;
-
-  if (issue.position_start !== null && issue.position_end !== null) {
-    // Apply at exact position if the text at that position matches
-    const textAtPosition = transcript.transcript_text.slice(issue.position_start, issue.position_end);
-    if (textAtPosition === issue.original_text) {
-      newText =
-        transcript.transcript_text.slice(0, issue.position_start) +
-        issue.suggestion +
-        transcript.transcript_text.slice(issue.position_end);
-    } else {
-      // Position mismatch (text may have shifted from prior edits), fall back to first occurrence
-      newText = transcript.transcript_text.replace(issue.original_text, issue.suggestion);
-    }
-  } else {
-    // No position info, replace first occurrence
-    newText = transcript.transcript_text.replace(issue.original_text, issue.suggestion);
-  }
-
-  // Only update if text actually changed
-  if (newText !== transcript.transcript_text) {
-    updateTranscript(issue.transcript_id, { transcript_text: newText });
-  }
-
-  return updateIssueStatus(issueId, "applied");
-}
-
-/**
- * Dismiss an issue without changing the transcript text.
- */
-export function dismissIssue(issueId: string): ProofreadIssue | null {
-  const issue = getProofreadIssue(issueId);
-  if (!issue) return null;
-  return updateIssueStatus(issueId, "dismissed");
-}
-
-/**
- * Get proofread statistics for a transcript.
- */
-export { getDbProofreadStats as getProofreadStats };
-
-/**
- * Export annotated transcript text with inline markers showing issues.
- * Format: [TYPE: "original" -> "suggestion"]
- */
-export function exportAnnotated(transcriptId: string): string {
-  const transcript = getTranscript(transcriptId);
-  if (!transcript || !transcript.transcript_text) {
-    throw new Error(`Transcript '${transcriptId}' not found or has no text.`);
-  }
-
-  const issues = listProofreadIssues(transcriptId, { status: "pending" });
-  if (issues.length === 0) return transcript.transcript_text;
-
-  // Sort issues by position_start descending so we can safely replace from end to start
-  // without shifting positions. Issues without positions are handled via string replacement.
-  const positionalIssues = issues
-    .filter((i) => i.position_start !== null && i.position_end !== null)
-    .sort((a, b) => (b.position_start ?? 0) - (a.position_start ?? 0));
-
-  const nonPositionalIssues = issues.filter((i) => i.position_start === null || i.position_end === null);
-
-  let text = transcript.transcript_text;
-
-  // Apply positional annotations from end to start
-  for (const issue of positionalIssues) {
-    const start = issue.position_start!;
-    const end = issue.position_end!;
-    const marker = formatMarker(issue);
-    text = text.slice(0, start) + marker + text.slice(end);
-  }
-
-  // Apply non-positional annotations via first occurrence replacement
-  for (const issue of nonPositionalIssues) {
-    const marker = formatMarker(issue);
-    const idx = text.indexOf(issue.original_text);
-    if (idx !== -1) {
-      text = text.slice(0, idx) + marker + text.slice(idx + issue.original_text.length);
-    }
-  }
-
-  return text;
-}
-
-function formatMarker(issue: ProofreadIssue): string {
-  const type = issue.issue_type.toUpperCase();
-  if (issue.suggestion) {
-    return `[${type}: "${issue.original_text}" -> "${issue.suggestion}"]`;
-  }
-  return `[${type}: "${issue.original_text}"]`;
-}