@hasna/microservices 0.0.8 → 0.0.9

package/microservices/microservice-transcriber/src/cli/index.ts

@@ -22,7 +22,8 @@ import {
   type TranscriptStatus,
   type TranscriptSourceType,
 } from "../db/transcripts.js";
-import { prepareAudio, detectSourceType, getVideoInfo, downloadAudio, downloadVideo, createClip, isPlaylistUrl, getPlaylistUrls, type TrimOptions } from "../lib/downloader.js";
+import { prepareAudio, detectSourceType, getVideoInfo, downloadAudio, downloadVideo, createClip, isPlaylistUrl, getPlaylistUrls, fetchComments, type TrimOptions } from "../lib/downloader.js";
+import { createComment, listComments, searchComments, getCommentStats, getTopComments, importComments } from "../db/comments.js";
 import { transcribeFile, checkProviders, toSrt, toVtt, toAss, toMarkdown, segmentByChapters, formatWithConfidence, estimateCost } from "../lib/providers.js";
 import { getConfig, setConfig, resetConfig, CONFIG_DEFAULTS, CONFIG_KEYS, type ConfigKey } from "../lib/config.js";
 import { summarizeText, extractHighlights, generateMeetingNotes, getDefaultSummaryProvider } from "../lib/summarizer.js";
@@ -33,6 +34,7 @@ import { createAnnotation, listAnnotations, deleteAnnotation, formatTimestamp as
 import { pushToNotion } from "../lib/notion.js";
 import { startLiveTranscription } from "../lib/live.js";
 import { wordDiff, formatDiff, diffStats } from "../lib/diff.js";
+import { proofreadTranscript, listIssues, applySuggestion, dismissIssue, getProofreadStats, exportAnnotated, type IssueType } from "../lib/proofread.js";
 
 const program = new Command();
 
@@ -56,6 +58,7 @@ program
   .option("--diarize", "Identify different speakers (ElevenLabs only)")
   .option("--vocab <words>", "Custom vocabulary hints (comma-separated, e.g. 'Karpathy,MicroGPT,SABR')")
   .option("--summarize", "Auto-summarize after transcription using AI")
+  .option("--comments", "Also fetch and store YouTube/Vimeo comments")
   .option("--force", "Re-transcribe even if URL was already transcribed")
   .option("--json", "Output as JSON")
   .action(async (rawSources: string[], opts) => {
@@ -202,6 +205,33 @@ program
           word_count: result.text.split(/\s+/).filter(Boolean).length, timestamp: new Date().toISOString(),
         });
 
+        // Fetch comments if requested
+        if (opts.comments && (sourceType === "youtube" || sourceType === "vimeo")) {
+          try {
+            if (!opts.json) process.stdout.write("  Fetching comments...");
+            const rawComments = await fetchComments(source);
+            if (rawComments.length > 0) {
+              const mapped = rawComments.map((c) => ({
+                platform: sourceType,
+                author: c.author,
+                author_handle: c.author_id,
+                comment_text: c.text,
+                likes: c.like_count,
+                reply_count: 0,
+                is_reply: c.parent !== null,
+                parent_comment_id: c.parent,
+                published_at: c.timestamp ? new Date(c.timestamp * 1000).toISOString() : null,
+              }));
+              importComments(record.id, mapped);
+              if (!opts.json) console.log(` ${rawComments.length} comment(s) imported.`);
+            } else {
+              if (!opts.json) console.log(" no comments found.");
+            }
+          } catch (e) {
+            if (!opts.json) console.error(`  Warning: comment fetch failed — ${e instanceof Error ? e.message : e}`);
+          }
+        }
+
         results.push({ source, id: record.id, success: true });
 
         if (opts.json && !isBatch) {
@@ -1171,6 +1201,92 @@ annoCmd
     else { console.error("Annotation not found."); process.exit(1); }
   });
 
+// ---------------------------------------------------------------------------
+// comments
+// ---------------------------------------------------------------------------
+
+const commentsCmd = program
+  .command("comments")
+  .description("Manage video comments extracted from YouTube/Vimeo");
+
+commentsCmd
+  .command("list <transcript-id>")
+  .description("List comments for a transcript")
+  .option("--top", "Sort by most liked")
+  .option("--limit <n>", "Max results", "20")
+  .option("--json", "Output as JSON")
+  .action((transcriptId: string, opts) => {
+    const comments = listComments(transcriptId, {
+      limit: parseInt(opts.limit),
+      top: opts.top,
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(comments, null, 2));
+      return;
+    }
+
+    if (comments.length === 0) {
+      console.log("No comments found.");
+      return;
+    }
+
+    for (const c of comments) {
+      const likesStr = c.likes > 0 ? ` [${c.likes} likes]` : "";
+      const replyStr = c.is_reply ? " (reply)" : "";
+      console.log(`${c.author ?? "Anonymous"}${replyStr}${likesStr}`);
+      console.log(`  ${c.comment_text.slice(0, 200)}${c.comment_text.length > 200 ? "..." : ""}`);
+      console.log();
+    }
+  });
+
+commentsCmd
+  .command("search <query>")
+  .description("Search comment text across all transcripts")
+  .option("--json", "Output as JSON")
+  .action((query: string, opts) => {
+    const results = searchComments(query);
+
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+
+    if (results.length === 0) {
+      console.log(`No comments matching '${query}'.`);
+      return;
+    }
+
+    console.log(`Found ${results.length} comment(s):\n`);
+    for (const c of results) {
+      const likesStr = c.likes > 0 ? ` [${c.likes} likes]` : "";
+      console.log(`${c.author ?? "Anonymous"}${likesStr} (transcript: ${c.transcript_id.slice(0, 8)})`);
+      console.log(`  ${c.comment_text.slice(0, 200)}${c.comment_text.length > 200 ? "..." : ""}`);
+      console.log();
+    }
+  });
+
+commentsCmd
+  .command("stats <transcript-id>")
+  .description("Show comment statistics for a transcript")
+  .option("--json", "Output as JSON")
+  .action((transcriptId: string, opts) => {
+    const stats = getCommentStats(transcriptId);
+
+    if (opts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+
+    console.log(`Total comments:  ${stats.total}`);
+    console.log(`Replies:         ${stats.replies}`);
+    console.log(`Unique authors:  ${stats.unique_authors}`);
+    console.log(`Avg likes:       ${stats.avg_likes}`);
+    if (stats.top_commenter) {
+      console.log(`Top commenter:   ${stats.top_commenter}`);
+    }
+  });
+
 // ---------------------------------------------------------------------------
 // watch-feed
 // ---------------------------------------------------------------------------
@@ -1344,4 +1460,134 @@ configCmd
     console.log("Config reset to defaults.");
   });
 
+// ---------------------------------------------------------------------------
+// proofread
+// ---------------------------------------------------------------------------
+
+const proofreadCmd = program
+  .command("proofread")
+  .description("AI-powered spellcheck and proofreading for transcripts");
+
+proofreadCmd
+  .command("run <transcript-id>")
+  .description("Run AI proofreading on a transcript (non-destructive)")
+  .option("--types <types>", "Comma-separated issue types: spelling,grammar,punctuation,clarity")
+  .option("--confidence <n>", "Minimum confidence threshold 0-1 (default 0.7)", parseFloat)
+  .option("--provider <provider>", "AI provider: openai or anthropic")
+  .option("--json", "Output as JSON")
+  .action(async (transcriptId: string, opts) => {
+    const types = opts.types ? opts.types.split(",").map((t: string) => t.trim()) as IssueType[] : undefined;
+    const confidence = opts.confidence ?? 0.7;
+
+    if (!opts.json) console.log(`Proofreading transcript ${transcriptId}...`);
+
+    try {
+      const issues = await proofreadTranscript(transcriptId, { types, confidence_threshold: confidence, provider: opts.provider });
+
+      if (opts.json) {
+        console.log(JSON.stringify(issues, null, 2));
+      } else {
+        console.log(`Found ${issues.length} issue(s):\n`);
+        for (const issue of issues) {
+          console.log(`  [${issue.issue_type}] "${issue.original_text}" -> "${issue.suggestion ?? "(no suggestion)"}" (${((issue.confidence ?? 0) * 100).toFixed(0)}%)`);
+          if (issue.explanation) console.log(`    ${issue.explanation}`);
+        }
+      }
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+proofreadCmd
+  .command("issues <transcript-id>")
+  .description("List proofread issues for a transcript")
+  .option("--type <type>", "Filter by issue type: spelling, grammar, punctuation, clarity")
+  .option("--pending", "Show only pending issues")
+  .option("--json", "Output as JSON")
+  .action((transcriptId: string, opts) => {
+    const filters: { issue_type?: IssueType; status?: "pending" } = {};
+    if (opts.type) filters.issue_type = opts.type as IssueType;
+    if (opts.pending) filters.status = "pending";
+
+    const issues = listIssues(transcriptId, filters);
+
+    if (opts.json) {
+      console.log(JSON.stringify(issues, null, 2));
+      return;
+    }
+
+    if (issues.length === 0) { console.log("No issues found."); return; }
+
+    for (const issue of issues) {
+      const conf = issue.confidence !== null ? ` ${(issue.confidence * 100).toFixed(0)}%` : "";
+      console.log(`${issue.id.slice(0, 8)}  [${issue.status.padEnd(9)}] [${issue.issue_type.padEnd(11)}]${conf}  "${issue.original_text}" -> "${issue.suggestion ?? "-"}"`);
+    }
+  });
+
+proofreadCmd
+  .command("apply <issue-id>")
+  .description("Apply a proofread suggestion (modifies transcript text)")
+  .option("--json", "Output as JSON")
+  .action((issueId: string, opts) => {
+    const updated = applySuggestion(issueId);
+    if (!updated) { console.error(`Issue '${issueId}' not found.`); process.exit(1); }
+
+    if (opts.json) {
+      console.log(JSON.stringify(updated, null, 2));
+    } else {
+      console.log(`Applied: "${updated.original_text}" -> "${updated.suggestion}"`);
+    }
+  });
+
+proofreadCmd
+  .command("dismiss <issue-id>")
+  .description("Dismiss a proofread issue without changing text")
+  .option("--json", "Output as JSON")
+  .action((issueId: string, opts) => {
+    const updated = dismissIssue(issueId);
+    if (!updated) { console.error(`Issue '${issueId}' not found.`); process.exit(1); }
+
+    if (opts.json) {
+      console.log(JSON.stringify(updated, null, 2));
+    } else {
+      console.log(`Dismissed: "${updated.original_text}"`);
+    }
+  });
+
+proofreadCmd
+  .command("export <transcript-id>")
+  .description("Export transcript with inline proofread annotations")
+  .action((transcriptId: string) => {
+    try {
+      const annotated = exportAnnotated(transcriptId);
+      console.log(annotated);
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : error}`);
+      process.exit(1);
+    }
+  });
+
+proofreadCmd
+  .command("stats <transcript-id>")
+  .description("Show proofread issue statistics")
+  .option("--json", "Output as JSON")
+  .action((transcriptId: string, opts) => {
+    const stats = getProofreadStats(transcriptId);
+
+    if (opts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+
+    console.log(`Total issues: ${stats.total}`);
+    console.log(`Pending: ${stats.pending} | Applied: ${stats.applied} | Dismissed: ${stats.dismissed}`);
+    if (Object.keys(stats.by_type).length > 0) {
+      console.log("\nBy type:");
+      for (const [type, count] of Object.entries(stats.by_type)) {
+        console.log(`  ${type.padEnd(12)} ${count}`);
+      }
+    }
+  });
+
 program.parse();

package/microservices/microservice-transcriber/src/db/comments.ts

@@ -0,0 +1,166 @@
+import { getDatabase } from "./database.js";
+
+export interface Comment {
+  id: string;
+  transcript_id: string;
+  platform: string;
+  author: string | null;
+  author_handle: string | null;
+  comment_text: string;
+  likes: number;
+  reply_count: number;
+  is_reply: number;
+  parent_comment_id: string | null;
+  published_at: string | null;
+  created_at: string;
+}
+
+export interface CreateCommentInput {
+  transcript_id: string;
+  platform?: string;
+  author?: string | null;
+  author_handle?: string | null;
+  comment_text: string;
+  likes?: number;
+  reply_count?: number;
+  is_reply?: boolean;
+  parent_comment_id?: string | null;
+  published_at?: string | null;
+}
+
+export interface ListCommentsOptions {
+  limit?: number;
+  offset?: number;
+  top?: boolean;
+}
+
+export interface CommentStats {
+  total: number;
+  replies: number;
+  unique_authors: number;
+  avg_likes: number;
+  top_commenter: string | null;
+}
+
+export function createComment(data: CreateCommentInput): Comment {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(`
+    INSERT INTO transcript_comments (id, transcript_id, platform, author, author_handle, comment_text, likes, reply_count, is_reply, parent_comment_id, published_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    data.transcript_id,
+    data.platform ?? "youtube",
+    data.author ?? null,
+    data.author_handle ?? null,
+    data.comment_text,
+    data.likes ?? 0,
+    data.reply_count ?? 0,
+    data.is_reply ? 1 : 0,
+    data.parent_comment_id ?? null,
+    data.published_at ?? null,
+  );
+
+  return getComment(id)!;
+}
+
+export function getComment(id: string): Comment | null {
+  const db = getDatabase();
+  return db.prepare("SELECT * FROM transcript_comments WHERE id = ?").get(id) as Comment | null;
+}
+
+export function listComments(transcriptId: string, options: ListCommentsOptions = {}): Comment[] {
+  const db = getDatabase();
+  const limit = options.limit ?? 50;
+  const offset = options.offset ?? 0;
+  const orderBy = options.top ? "likes DESC" : "created_at ASC";
+
+  return db
+    .prepare(`SELECT * FROM transcript_comments WHERE transcript_id = ? ORDER BY ${orderBy} LIMIT ? OFFSET ?`)
+    .all(transcriptId, limit, offset) as Comment[];
+}
+
+export function deleteComment(id: string): boolean {
+  const db = getDatabase();
+  return db.prepare("DELETE FROM transcript_comments WHERE id = ?").run(id).changes > 0;
+}
+
+export function getTopComments(transcriptId: string, limit = 10): Comment[] {
+  const db = getDatabase();
+  return db
+    .prepare("SELECT * FROM transcript_comments WHERE transcript_id = ? ORDER BY likes DESC LIMIT ?")
+    .all(transcriptId, limit) as Comment[];
+}
+
+export function searchComments(query: string): Comment[] {
+  const db = getDatabase();
+  const q = `%${query}%`;
+  return db
+    .prepare("SELECT * FROM transcript_comments WHERE comment_text LIKE ? ORDER BY likes DESC LIMIT 50")
+    .all(q) as Comment[];
+}
+
+export function getCommentStats(transcriptId: string): CommentStats {
+  const db = getDatabase();
+
+  const total = (
+    db.prepare("SELECT COUNT(*) as n FROM transcript_comments WHERE transcript_id = ?").get(transcriptId) as { n: number }
+  ).n;
+
+  const replies = (
+    db.prepare("SELECT COUNT(*) as n FROM transcript_comments WHERE transcript_id = ? AND is_reply = 1").get(transcriptId) as { n: number }
+  ).n;
+
+  const uniqueAuthors = (
+    db.prepare("SELECT COUNT(DISTINCT author) as n FROM transcript_comments WHERE transcript_id = ? AND author IS NOT NULL").get(transcriptId) as { n: number }
+  ).n;
+
+  const avgLikes = (
+    db.prepare("SELECT AVG(likes) as avg FROM transcript_comments WHERE transcript_id = ?").get(transcriptId) as { avg: number | null }
+  ).avg ?? 0;
+
+  const topRow = db
+    .prepare("SELECT author, COUNT(*) as cnt FROM transcript_comments WHERE transcript_id = ? AND author IS NOT NULL GROUP BY author ORDER BY cnt DESC LIMIT 1")
+    .get(transcriptId) as { author: string; cnt: number } | null;
+
+  return {
+    total,
+    replies,
+    unique_authors: uniqueAuthors,
+    avg_likes: Math.round(avgLikes * 100) / 100,
+    top_commenter: topRow?.author ?? null,
+  };
+}
+
+export function importComments(transcriptId: string, comments: Array<Omit<CreateCommentInput, "transcript_id">>): number {
+  const db = getDatabase();
+  const stmt = db.prepare(`
+    INSERT INTO transcript_comments (id, transcript_id, platform, author, author_handle, comment_text, likes, reply_count, is_reply, parent_comment_id, published_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  let count = 0;
+  const transaction = db.transaction(() => {
+    for (const c of comments) {
+      stmt.run(
+        crypto.randomUUID(),
+        transcriptId,
+        c.platform ?? "youtube",
+        c.author ?? null,
+        c.author_handle ?? null,
+        c.comment_text,
+        c.likes ?? 0,
+        c.reply_count ?? 0,
+        c.is_reply ? 1 : 0,
+        c.parent_comment_id ?? null,
+        c.published_at ?? null,
+      );
+      count++;
+    }
+  });
+  transaction();
+
+  return count;
+}

package/microservices/microservice-transcriber/src/db/migrations.ts

@@ -69,4 +69,50 @@ export const MIGRATIONS: MigrationEntry[] = [
       CREATE INDEX IF NOT EXISTS idx_annotations_transcript ON annotations(transcript_id);
     `,
   },
+  {
+    id: 5,
+    name: "add_transcript_comments",
+    sql: `
+      CREATE TABLE IF NOT EXISTS transcript_comments (
+        id TEXT PRIMARY KEY,
+        transcript_id TEXT NOT NULL,
+        platform TEXT NOT NULL DEFAULT 'youtube',
+        author TEXT,
+        author_handle TEXT,
+        comment_text TEXT NOT NULL,
+        likes INTEGER DEFAULT 0,
+        reply_count INTEGER DEFAULT 0,
+        is_reply INTEGER DEFAULT 0,
+        parent_comment_id TEXT,
+        published_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        FOREIGN KEY (transcript_id) REFERENCES transcripts(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_comments_transcript ON transcript_comments(transcript_id);
+      CREATE INDEX IF NOT EXISTS idx_comments_likes ON transcript_comments(likes DESC);
+    `,
+  },
+  {
+    id: 6,
+    name: "add_proofread_issues",
+    sql: `
+      CREATE TABLE proofread_issues (
+        id TEXT PRIMARY KEY,
+        transcript_id TEXT NOT NULL,
+        issue_type TEXT NOT NULL CHECK(issue_type IN ('spelling','grammar','punctuation','clarity')),
+        position_start INTEGER,
+        position_end INTEGER,
+        original_text TEXT NOT NULL,
+        suggestion TEXT,
+        confidence REAL,
+        explanation TEXT,
+        status TEXT DEFAULT 'pending' CHECK(status IN ('pending','applied','dismissed')),
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        FOREIGN KEY (transcript_id) REFERENCES transcripts(id) ON DELETE CASCADE
+      );
+      CREATE INDEX idx_proofread_transcript ON proofread_issues(transcript_id);
+      CREATE INDEX idx_proofread_type ON proofread_issues(issue_type);
+      CREATE INDEX idx_proofread_status ON proofread_issues(status);
+    `,
+  },
 ];

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

@@ -0,0 +1,119 @@
+import { getDatabase } from "./database.js";
+
+export type IssueType = "spelling" | "grammar" | "punctuation" | "clarity";
+export type IssueStatus = "pending" | "applied" | "dismissed";
+
+export interface ProofreadIssue {
+  id: string;
+  transcript_id: string;
+  issue_type: IssueType;
+  position_start: number | null;
+  position_end: number | null;
+  original_text: string;
+  suggestion: string | null;
+  confidence: number | null;
+  explanation: string | null;
+  status: IssueStatus;
+  created_at: string;
+}
+
+export interface CreateProofreadIssueInput {
+  transcript_id: string;
+  issue_type: IssueType;
+  position_start?: number;
+  position_end?: number;
+  original_text: string;
+  suggestion?: string;
+  confidence?: number;
+  explanation?: string;
+}
+
+export interface ListProofreadIssuesOptions {
+  issue_type?: IssueType;
+  status?: IssueStatus;
+}
+
+export function createProofreadIssue(input: CreateProofreadIssueInput): ProofreadIssue {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  db.prepare(`
+    INSERT INTO proofread_issues (id, transcript_id, issue_type, position_start, position_end, original_text, suggestion, confidence, explanation)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    input.transcript_id,
+    input.issue_type,
+    input.position_start ?? null,
+    input.position_end ?? null,
+    input.original_text,
+    input.suggestion ?? null,
+    input.confidence ?? null,
+    input.explanation ?? null
+  );
+  return getProofreadIssue(id)!;
+}
+
+export function getProofreadIssue(id: string): ProofreadIssue | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM proofread_issues WHERE id = ?").get(id) as ProofreadIssue | null;
+  return row ?? null;
+}
+
+export function listProofreadIssues(transcriptId: string, options: ListProofreadIssuesOptions = {}): ProofreadIssue[] {
+  const db = getDatabase();
+  const conditions: string[] = ["transcript_id = ?"];
+  const values: unknown[] = [transcriptId];
+
+  if (options.issue_type) { conditions.push("issue_type = ?"); values.push(options.issue_type); }
+  if (options.status) { conditions.push("status = ?"); values.push(options.status); }
+
+  const where = conditions.join(" AND ");
+  return db
+    .prepare(`SELECT * FROM proofread_issues WHERE ${where} ORDER BY position_start ASC, created_at ASC`)
+    .all(...values) as ProofreadIssue[];
+}
+
+export function updateIssueStatus(id: string, status: IssueStatus): ProofreadIssue | null {
+  const db = getDatabase();
+  const existing = getProofreadIssue(id);
+  if (!existing) return null;
+  db.prepare("UPDATE proofread_issues SET status = ? WHERE id = ?").run(status, id);
+  return getProofreadIssue(id);
+}
+
+export function deleteProofreadIssuesByTranscript(transcriptId: string): number {
+  const db = getDatabase();
+  return db.prepare("DELETE FROM proofread_issues WHERE transcript_id = ?").run(transcriptId).changes;
+}
+
+export interface ProofreadStats {
+  total: number;
+  by_type: Record<string, number>;
+  pending: number;
+  applied: number;
+  dismissed: number;
+}
+
+export function getProofreadStats(transcriptId: string): ProofreadStats {
+  const db = getDatabase();
+
+  const total = (db.prepare("SELECT COUNT(*) as n FROM proofread_issues WHERE transcript_id = ?").get(transcriptId) as { n: number }).n;
+
+  const byType = db
+    .prepare("SELECT issue_type, COUNT(*) as n FROM proofread_issues WHERE transcript_id = ? GROUP BY issue_type")
+    .all(transcriptId) as { issue_type: string; n: number }[];
+
+  const byStatus = db
+    .prepare("SELECT status, COUNT(*) as n FROM proofread_issues WHERE transcript_id = ? GROUP BY status")
+    .all(transcriptId) as { status: string; n: number }[];
+
+  const statusMap = Object.fromEntries(byStatus.map((r) => [r.status, r.n]));
+
+  return {
+    total,
+    by_type: Object.fromEntries(byType.map((r) => [r.issue_type, r.n])),
+    pending: statusMap["pending"] ?? 0,
+    applied: statusMap["applied"] ?? 0,
+    dismissed: statusMap["dismissed"] ?? 0,
+  };
+}

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

@@ -556,6 +556,74 @@ export async function splitAudioIntoChunks(
   return chunks;
 }
 
+/**
+ * Raw comment from yt-dlp .info.json comments array.
+ */
+export interface RawComment {
+  author: string | null;
+  author_id: string | null;
+  text: string;
+  like_count: number;
+  timestamp: number | null;
+  parent: string | null; // "root" for top-level, comment id for replies
+  id: string;
+}
+
+/**
+ * Fetch comments for a video URL using yt-dlp --write-comments.
+ * Downloads only the .info.json (no media) and parses the comments array.
+ */
+export async function fetchComments(url: string): Promise<RawComment[]> {
+  const tempId = crypto.randomUUID();
+  const outputTemplate = join(tmpdir(), `comments-${tempId}`);
+
+  const proc = Bun.spawn(
+    [ytdlp(), "--write-comments", "--skip-download", "--no-write-thumbnail", "-o", outputTemplate, url],
+    { stdout: "pipe", stderr: "pipe" }
+  );
+
+  const [exitCode, , stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+
+  if (exitCode !== 0) {
+    throw new Error(`yt-dlp comment fetch failed (exit ${exitCode}): ${stderr.trim()}`);
+  }
+
+  // yt-dlp writes <output>.info.json
+  const infoPath = `${outputTemplate}.info.json`;
+  const { readFileSync, unlinkSync: unlinkFile, existsSync: fileExists } = await import("node:fs");
+
+  if (!fileExists(infoPath)) {
+    throw new Error("yt-dlp did not produce an info.json file for comments");
+  }
+
+  try {
+    const raw = JSON.parse(readFileSync(infoPath, "utf8"));
+    const comments: RawComment[] = [];
+
+    if (Array.isArray(raw.comments)) {
+      for (const c of raw.comments) {
+        comments.push({
+          author: c.author ?? null,
+          author_id: c.author_id ?? null,
+          text: typeof c.text === "string" ? c.text : String(c.text ?? ""),
+          like_count: typeof c.like_count === "number" ? c.like_count : 0,
+          timestamp: typeof c.timestamp === "number" ? c.timestamp : null,
+          parent: c.parent === "root" ? null : (c.parent ?? null),
+          id: c.id ?? crypto.randomUUID(),
+        });
+      }
+    }
+
+    return comments;
+  } finally {
+    try { unlinkFile(infoPath); } catch {}
+  }
+}
+
 /**
  * Check whether yt-dlp is available on the system.
  */

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

@@ -0,0 +1,296 @@
+/**
+ * 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}"]`;
+}

package/microservices/microservice-transcriber/src/mcp/index.ts

@@ -23,7 +23,8 @@ import {
   type TranscriptStatus,
   type TranscriptSourceType,
 } from "../db/transcripts.js";
-import { prepareAudio, detectSourceType, getVideoInfo, downloadAudio, downloadVideo, createClip, isPlaylistUrl, getPlaylistUrls, type TrimOptions } from "../lib/downloader.js";
+import { prepareAudio, detectSourceType, getVideoInfo, downloadAudio, downloadVideo, createClip, isPlaylistUrl, getPlaylistUrls, fetchComments, type TrimOptions } from "../lib/downloader.js";
+import { listComments, getTopComments, searchComments, getCommentStats, importComments } from "../db/comments.js";
 import { getConfig, setConfig, resetConfig } from "../lib/config.js";
 import { summarizeText, extractHighlights, generateMeetingNotes, getDefaultSummaryProvider } from "../lib/summarizer.js";
 import { translateText } from "../lib/translator.js";
@@ -31,6 +32,7 @@ import { fetchFeedEpisodes } from "../lib/feeds.js";
 import { createAnnotation, listAnnotations, deleteAnnotation } from "../db/annotations.js";
 import { wordDiff, diffStats, formatDiff } from "../lib/diff.js";
 import { transcribeFile, checkProviders, toSrt, toVtt, toAss, toMarkdown, segmentByChapters, formatWithConfidence } from "../lib/providers.js";
+import { proofreadTranscript, listIssues, applySuggestion, dismissIssue, getProofreadStats, exportAnnotated, type IssueType } from "../lib/proofread.js";
 
 const server = new McpServer({
   name: "microservice-transcriber",
@@ -63,9 +65,10 @@ server.registerTool(
       diarize: z.boolean().optional().describe("Identify different speakers — ElevenLabs only"),
       vocab: z.array(z.string()).optional().describe("Custom vocabulary hints for accuracy (e.g. ['Karpathy', 'MicroGPT'])"),
       force: z.boolean().optional().describe("Re-transcribe even if URL already exists in DB"),
+      comments: z.boolean().optional().describe("Also fetch and store YouTube/Vimeo comments"),
     },
   },
-  async ({ source, provider = "elevenlabs", language, title, start, end, diarize, vocab, force }) => {
+  async ({ source, provider = "elevenlabs", language, title, start, end, diarize, vocab, force, comments: fetchCommentsFlag }) => {
     // Duplicate detection
     if (!force) {
       const existing = findBySourceUrl(source);
@@ -129,8 +132,33 @@ server.registerTool(
         },
       });
 
+      // Fetch comments if requested
+      let commentCount = 0;
+      if (fetchCommentsFlag && (sourceType === "youtube" || sourceType === "vimeo")) {
+        try {
+          const rawComments = await fetchComments(source);
+          if (rawComments.length > 0) {
+            const mapped = rawComments.map((c) => ({
+              platform: sourceType,
+              author: c.author,
+              author_handle: c.author_id,
+              comment_text: c.text,
+              likes: c.like_count,
+              reply_count: 0,
+              is_reply: c.parent !== null,
+              parent_comment_id: c.parent,
+              published_at: c.timestamp ? new Date(c.timestamp * 1000).toISOString() : null,
+            }));
+            commentCount = importComments(record.id, mapped);
+          }
+        } catch {
+          // Comment fetch is best-effort — don't fail the transcription
+        }
+      }
+
+      const finalResult = { ...getTranscript(record.id), comments_imported: commentCount };
       return {
-        content: [{ type: "text", text: JSON.stringify(updated, null, 2) }],
+        content: [{ type: "text", text: JSON.stringify(finalResult, null, 2) }],
       };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -943,6 +971,86 @@ server.registerTool(
   }
 );
 
+// ---------------------------------------------------------------------------
+// list_comments
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "list_comments",
+  {
+    title: "List Comments",
+    description: "List comments for a transcript, optionally sorted by likes.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+      top: z.boolean().optional().describe("Sort by most liked"),
+      limit: z.number().optional().describe("Max results (default 50)"),
+      offset: z.number().optional().describe("Offset for pagination"),
+    },
+  },
+  async ({ transcript_id, top, limit, offset }) => {
+    const comments = listComments(transcript_id, { top, limit, offset });
+    return { content: [{ type: "text", text: JSON.stringify(comments, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// top_comments
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "top_comments",
+  {
+    title: "Top Comments",
+    description: "Get the most liked comments for a transcript.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+      limit: z.number().optional().describe("Number of top comments (default 10)"),
+    },
+  },
+  async ({ transcript_id, limit }) => {
+    const comments = getTopComments(transcript_id, limit);
+    return { content: [{ type: "text", text: JSON.stringify(comments, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// search_comments
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "search_comments",
+  {
+    title: "Search Comments",
+    description: "Search comment text across all transcripts using LIKE matching.",
+    inputSchema: {
+      query: z.string().describe("Search query"),
+    },
+  },
+  async ({ query }) => {
+    const results = searchComments(query);
+    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// comment_stats
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "comment_stats",
+  {
+    title: "Comment Stats",
+    description: "Get comment statistics for a transcript: total, replies, unique authors, avg likes, top commenter.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+    },
+  },
+  async ({ transcript_id }) => {
+    const stats = getCommentStats(transcript_id);
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+  }
+);
+
 // ---------------------------------------------------------------------------
 // get_config / set_config
 // ---------------------------------------------------------------------------
@@ -991,6 +1099,142 @@ server.registerTool(
   }
 );
 
+// ---------------------------------------------------------------------------
+// proofread_transcript
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "proofread_transcript",
+  {
+    title: "Proofread Transcript",
+    description: "Run AI-powered spellcheck/proofread on a transcript. Finds spelling, grammar, punctuation, and clarity issues. Non-destructive: stores issues in DB without modifying transcript text.",
+    inputSchema: {
+      id: z.string().describe("Transcript ID"),
+      types: z.array(z.enum(["spelling", "grammar", "punctuation", "clarity"])).optional().describe("Issue types to check (default: all)"),
+      confidence_threshold: z.number().optional().describe("Minimum confidence 0-1 (default: 0.7)"),
+      provider: z.enum(["openai", "anthropic"]).optional().describe("AI provider (auto-detected from env)"),
+    },
+  },
+  async ({ id, types, confidence_threshold, provider }) => {
+    try {
+      const issues = await proofreadTranscript(id, {
+        types: types as IssueType[] | undefined,
+        confidence_threshold,
+        provider: provider as "openai" | "anthropic" | undefined,
+      });
+      return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Proofread failed: ${error instanceof Error ? error.message : error}` }], isError: true };
+    }
+  }
+);
+
+// ---------------------------------------------------------------------------
+// list_proofread_issues
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "list_proofread_issues",
+  {
+    title: "List Proofread Issues",
+    description: "List proofread issues for a transcript with optional filters.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+      issue_type: z.enum(["spelling", "grammar", "punctuation", "clarity"]).optional().describe("Filter by issue type"),
+      status: z.enum(["pending", "applied", "dismissed"]).optional().describe("Filter by status"),
+    },
+  },
+  async ({ transcript_id, issue_type, status }) => {
+    const issues = listIssues(transcript_id, {
+      issue_type: issue_type as IssueType | undefined,
+      status: status as "pending" | "applied" | "dismissed" | undefined,
+    });
+    return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// apply_suggestion
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "apply_suggestion",
+  {
+    title: "Apply Proofread Suggestion",
+    description: "Apply a proofread suggestion to the transcript text. Replaces the original text with the suggestion and marks the issue as applied.",
+    inputSchema: {
+      issue_id: z.string().describe("Proofread issue ID"),
+    },
+  },
+  async ({ issue_id }) => {
+    const result = applySuggestion(issue_id);
+    if (!result) return { content: [{ type: "text", text: `Issue '${issue_id}' not found.` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// dismiss_issue
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "dismiss_issue",
+  {
+    title: "Dismiss Proofread Issue",
+    description: "Dismiss a proofread issue without modifying the transcript text.",
+    inputSchema: {
+      issue_id: z.string().describe("Proofread issue ID"),
+    },
+  },
+  async ({ issue_id }) => {
+    const result = dismissIssue(issue_id);
+    if (!result) return { content: [{ type: "text", text: `Issue '${issue_id}' not found.` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// proofread_stats
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "proofread_stats",
+  {
+    title: "Proofread Stats",
+    description: "Get proofread issue statistics for a transcript: total, by type, pending/applied/dismissed counts.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+    },
+  },
+  async ({ transcript_id }) => {
+    const stats = getProofreadStats(transcript_id);
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+  }
+);
+
+// ---------------------------------------------------------------------------
+// export_annotated
+// ---------------------------------------------------------------------------
+
+server.registerTool(
+  "export_annotated",
+  {
+    title: "Export Annotated Transcript",
+    description: "Export transcript text with inline proofread annotations showing pending issues as [TYPE: \"original\" -> \"suggestion\"] markers.",
+    inputSchema: {
+      transcript_id: z.string().describe("Transcript ID"),
+    },
+  },
+  async ({ transcript_id }) => {
+    try {
+      const text = exportAnnotated(transcript_id);
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Export failed: ${error instanceof Error ? error.message : error}` }], isError: true };
+    }
+  }
+);
+
 // ---------------------------------------------------------------------------
 // search_tools / describe_tools
 // ---------------------------------------------------------------------------
@@ -1021,6 +1265,16 @@ server.registerTool(
       "get_config",
       "set_config",
       "reset_config",
+      "list_comments",
+      "top_comments",
+      "search_comments",
+      "comment_stats",
+      "proofread_transcript",
+      "list_proofread_issues",
+      "apply_suggestion",
+      "dismiss_issue",
+      "proofread_stats",
+      "export_annotated",
       "search_tools",
       "describe_tools",
     ];
@@ -1048,6 +1302,12 @@ server.registerTool(
       export_transcript: "Export as txt/srt/json. Params: id, format?",
       transcript_stats: "Counts by status and provider.",
       check_providers: "Check which API keys are configured.",
+      proofread_transcript: "AI spellcheck/proofread. Params: id, types?, confidence_threshold?, provider?",
+      list_proofread_issues: "List proofread issues. Params: transcript_id, issue_type?, status?",
+      apply_suggestion: "Apply a proofread suggestion. Params: issue_id",
+      dismiss_issue: "Dismiss a proofread issue. Params: issue_id",
+      proofread_stats: "Proofread stats. Params: transcript_id",
+      export_annotated: "Export with inline annotations. Params: transcript_id",
     };
     const result = names.map((n) => `${n}: ${descriptions[n] || "See tool schema"}`).join("\n");
     return { content: [{ type: "text" as const, text: result }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/microservices",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Mini business apps for AI agents - invoices, contacts, bookkeeping and more, each with its own SQLite database",
   "type": "module",
   "bin": {