fireflies-api 0.5.1 → 0.6.0

package/dist/middleware/express.cjs

@@ -291,8 +291,8 @@ async function retry(fn, options) {
       if (attempt >= maxRetries || !shouldRetry(error, attempt)) {
         throw error;
       }
-      const delay = calculateDelay(error, attempt, baseDelay, maxDelay);
-      await sleep(delay);
+      const delay2 = calculateDelay(error, attempt, baseDelay, maxDelay);
+      await sleep(delay2);
     }
   }
   throw lastError;
@@ -441,9 +441,9 @@ var GraphQLClient = class {
     if (!this.rateLimitTracker || !this.rateLimitConfig?.throttle) {
       return;
     }
-    const delay = this.rateLimitTracker.getThrottleDelay(this.rateLimitConfig.throttle);
-    if (delay > 0) {
-      await sleep2(delay);
+    const delay2 = this.rateLimitTracker.getThrottleDelay(this.rateLimitConfig.throttle);
+    if (delay2 > 0) {
+      await sleep2(delay2);
     }
   }
   /**
@@ -1097,6 +1097,46 @@ function buildAggregatedResult(items, transcriptsProcessed, transcriptsWithItems
   };
 }
 
+// src/helpers/batch.ts
+async function* batch(items, processor, options = {}) {
+  const { delayMs = 100, handleRateLimit = true, maxRateLimitRetries = 3 } = options;
+  let isFirst = true;
+  for await (const item of items) {
+    if (!isFirst && delayMs > 0) {
+      await delay(delayMs);
+    }
+    isFirst = false;
+    yield await processWithRetry(item, processor, {
+      handleRateLimit,
+      maxRateLimitRetries
+    });
+  }
+}
+async function processWithRetry(item, processor, options) {
+  const { handleRateLimit, maxRateLimitRetries } = options;
+  let retries = 0;
+  while (true) {
+    try {
+      const result = await processor(item);
+      return { item, result };
+    } catch (err) {
+      if (handleRateLimit && err instanceof RateLimitError && retries < maxRateLimitRetries) {
+        const waitTime = err.retryAfter ?? 1e3;
+        await delay(waitTime);
+        retries++;
+        continue;
+      }
+      return {
+        item,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/helpers/domain-utils.ts
 function extractDomain(email) {
   const atIndex = email.indexOf("@");
@@ -1112,6 +1152,332 @@ function hasExternalParticipants(participants, internalDomain) {
   });
 }
 
+// src/helpers/markdown.ts
+var DEFAULT_OPTIONS2 = {
+  includeMetadata: true,
+  includeSummary: true,
+  includeActionItems: true,
+  actionItemFormat: "checkbox",
+  includeTimestamps: false,
+  speakerFormat: "bold",
+  groupBySpeaker: true
+};
+async function transcriptToMarkdown(transcript, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const sections = [];
+  if (opts.includeMetadata) {
+    sections.push(formatMetadata(transcript));
+  }
+  if (opts.includeSummary && transcript.summary) {
+    sections.push(formatSummary(transcript.summary, opts));
+  }
+  if (transcript.sentences && transcript.sentences.length > 0) {
+    sections.push(formatTranscript(transcript.sentences, opts));
+  }
+  const content = sections.join("\n\n---\n\n");
+  await writeIfOutputPath(content, options.outputPath);
+  return content;
+}
+function formatMetadata(transcript) {
+  const lines = [`# ${transcript.title || "Untitled Meeting"}`];
+  if (transcript.dateString) {
+    lines.push(`
+**Date:** ${formatDate(transcript.dateString)}`);
+  }
+  const duration = calculateDuration(transcript);
+  if (duration > 0) {
+    lines.push(`**Duration:** ${formatDuration(duration)}`);
+  }
+  const participants = getParticipantNames(transcript);
+  if (participants.length > 0) {
+    lines.push(`**Participants:** ${participants.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function calculateDuration(transcript) {
+  if (transcript.sentences && transcript.sentences.length > 0) {
+    const lastSentence = transcript.sentences[transcript.sentences.length - 1];
+    if (lastSentence) {
+      return parseFloat(lastSentence.end_time);
+    }
+  }
+  return transcript.duration || 0;
+}
+function formatSummary(summary, opts) {
+  const sections = ["## Summary"];
+  if (summary.gist) {
+    sections.push("", summary.gist);
+  }
+  if (summary.bullet_gist) {
+    const bullets = parseMultilineField(summary.bullet_gist);
+    if (bullets.length > 0) {
+      sections.push("", "### Key Points");
+      sections.push(bullets.map((p) => `- ${p}`).join("\n"));
+    }
+  }
+  if (opts.includeActionItems && summary.action_items) {
+    const items = parseMultilineField(summary.action_items);
+    if (items.length > 0) {
+      sections.push("", "### Action Items");
+      const prefix = opts.actionItemFormat === "checkbox" ? "- [ ] " : "- ";
+      sections.push(items.map((a) => `${prefix}${a}`).join("\n"));
+    }
+  }
+  return sections.join("\n");
+}
+function formatTranscript(sentences, opts) {
+  const lines = ["## Transcript"];
+  if (opts.groupBySpeaker) {
+    const groups = groupSentencesBySpeaker(sentences);
+    for (const group of groups) {
+      lines.push("", formatSpeakerGroup(group, opts));
+    }
+  } else {
+    for (const sentence of sentences) {
+      lines.push("", formatSentence(sentence, opts));
+    }
+  }
+  return lines.join("\n");
+}
+function groupSentencesBySpeaker(sentences) {
+  const groups = [];
+  let current = null;
+  for (const sentence of sentences) {
+    if (!current || current.speakerName !== sentence.speaker_name) {
+      current = { speakerName: sentence.speaker_name, sentences: [] };
+      groups.push(current);
+    }
+    current.sentences.push(sentence);
+  }
+  return groups;
+}
+function formatSpeakerGroup(group, opts) {
+  const speaker = formatSpeakerName(group.speakerName, opts.speakerFormat);
+  const text = group.sentences.map((s) => s.text).join(" ");
+  const firstSentence = group.sentences[0];
+  if (opts.includeTimestamps && firstSentence) {
+    const timestamp = formatTimestamp(firstSentence.start_time);
+    return `${timestamp} ${speaker} ${text}`;
+  }
+  return `${speaker} ${text}`;
+}
+function formatSentence(sentence, opts) {
+  const speaker = formatSpeakerName(sentence.speaker_name, opts.speakerFormat);
+  if (opts.includeTimestamps) {
+    const timestamp = formatTimestamp(sentence.start_time);
+    return `${timestamp} ${speaker} ${sentence.text}`;
+  }
+  return `${speaker} ${sentence.text}`;
+}
+function formatSpeakerName(name, format) {
+  switch (format) {
+    case "bold":
+      return `**${name}:**`;
+    case "plain":
+      return `${name}:`;
+  }
+}
+function formatTimestamp(startTime) {
+  const seconds = parseFloat(startTime);
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `[${mins}:${secs.toString().padStart(2, "0")}]`;
+}
+function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  if (hours > 0) {
+    return `${hours}h ${mins}m`;
+  }
+  return `${mins} minutes`;
+}
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function getParticipantNames(transcript) {
+  if (transcript.meeting_attendees?.length) {
+    return transcript.meeting_attendees.map((a) => a.displayName || a.name || a.email).filter(Boolean);
+  }
+  return transcript.speakers?.map((s) => s.name) || [];
+}
+function parseMultilineField(value) {
+  return value.split(/\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+async function writeIfOutputPath(content, outputPath) {
+  if (outputPath) {
+    const { writeFile } = await import('fs/promises');
+    await writeFile(outputPath, content, "utf-8");
+  }
+}
+
+// src/helpers/export-formats.ts
+var DEFAULT_TEXT_OPTIONS = {
+  includeTimestamps: false,
+  includeMetadata: true
+};
+var DEFAULT_CSV_OPTIONS = {
+  includeHeader: true,
+  delimiter: ","
+};
+function transcriptToText(transcript, options = {}) {
+  const opts = { ...DEFAULT_TEXT_OPTIONS, ...options };
+  const sections = [];
+  if (opts.includeMetadata) {
+    sections.push(formatTextMetadata(transcript));
+  }
+  if (transcript.sentences && transcript.sentences.length > 0) {
+    sections.push(formatTextTranscript(transcript.sentences, opts));
+  }
+  return sections.join("\n\n");
+}
+function transcriptToCsv(transcript, options = {}) {
+  const opts = { ...DEFAULT_CSV_OPTIONS, ...options };
+  const d = opts.delimiter;
+  const lines = [];
+  if (opts.includeHeader) {
+    lines.push(`timestamp${d}speaker${d}text${d}is_question${d}is_task`);
+  }
+  for (const sentence of transcript.sentences) {
+    const isQuestion = Boolean(sentence.ai_filters?.question);
+    const isTask = Boolean(sentence.ai_filters?.task);
+    const row = [
+      sentence.start_time,
+      escapeCsvField(sentence.speaker_name, d),
+      escapeCsvField(sentence.text, d),
+      String(isQuestion),
+      String(isTask)
+    ];
+    lines.push(row.join(d));
+  }
+  return lines.join("\n");
+}
+function sanitizeFilename(title) {
+  if (!title.trim()) {
+    return "untitled";
+  }
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+}
+function generateExportFilename(transcript, extension) {
+  const sanitizedTitle = sanitizeFilename(transcript.title);
+  let datePrefix = "";
+  if (transcript.dateString) {
+    try {
+      const date = new Date(transcript.dateString);
+      if (!Number.isNaN(date.getTime())) {
+        datePrefix = `${date.toISOString().slice(0, 10)}-`;
+      }
+    } catch {
+    }
+  }
+  return `${datePrefix}${sanitizedTitle}.${extension}`;
+}
+async function exportTranscript(transcript, format) {
+  switch (format) {
+    case "markdown":
+      return transcriptToMarkdown(transcript);
+    case "json":
+      return JSON.stringify(transcript, null, 2);
+    case "txt":
+      return transcriptToText(transcript);
+    case "csv":
+      return transcriptToCsv(transcript);
+  }
+}
+async function createZipArchive(files) {
+  const archiver = await import('archiver');
+  const { Writable } = await import('stream');
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const archive = archiver.default("zip", { zlib: { level: 9 } });
+    const writable = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+    writable.on("finish", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    archive.on("error", reject);
+    archive.pipe(writable);
+    for (const file of files) {
+      archive.append(file.content, { name: file.filename });
+    }
+    archive.finalize();
+  });
+}
+function formatTextMetadata(transcript) {
+  const lines = [];
+  lines.push(transcript.title || "Untitled Meeting");
+  if (transcript.dateString) {
+    lines.push(`Date: ${formatDate2(transcript.dateString)}`);
+  }
+  const participants = getParticipantNames2(transcript);
+  if (participants.length > 0) {
+    lines.push(`Participants: ${participants.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function formatTextTranscript(sentences, opts) {
+  const groups = groupSentencesBySpeaker2(sentences);
+  const lines = [];
+  for (const group of groups) {
+    const text = group.sentences.map((s) => s.text).join(" ");
+    const speaker = group.speakerName || "Unknown";
+    const firstSentence = group.sentences[0];
+    if (opts.includeTimestamps && firstSentence) {
+      const timestamp = formatTimestamp2(firstSentence.start_time);
+      lines.push(`${timestamp} ${speaker}: ${text}`);
+    } else {
+      lines.push(`${speaker}: ${text}`);
+    }
+  }
+  return lines.join("\n");
+}
+function groupSentencesBySpeaker2(sentences) {
+  const groups = [];
+  let current = null;
+  for (const sentence of sentences) {
+    if (!current || current.speakerName !== sentence.speaker_name) {
+      current = { speakerName: sentence.speaker_name, sentences: [] };
+      groups.push(current);
+    }
+    current.sentences.push(sentence);
+  }
+  return groups;
+}
+function formatTimestamp2(startTime) {
+  const seconds = parseFloat(startTime);
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `[${mins}:${secs.toString().padStart(2, "0")}]`;
+}
+function formatDate2(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function getParticipantNames2(transcript) {
+  if (transcript.meeting_attendees?.length) {
+    return transcript.meeting_attendees.map((a) => a.displayName || a.name || a.email).filter(Boolean);
+  }
+  return transcript.speakers?.map((s) => s.name) || [];
+}
+function escapeCsvField(field, delimiter) {
+  if (field.includes('"') || field.includes(delimiter) || field.includes("\n")) {
+    return `"${field.replace(/"/g, '""')}"`;
+  }
+  return field;
+}
+
 // src/helpers/meeting-insights.ts
 function analyzeMeetings(transcripts, options = {}) {
   const { speakers, groupBy, topSpeakersCount = 10, topParticipantsCount = 10 } = options;
@@ -1585,6 +1951,21 @@ var TRANSCRIPT_LIST_FIELDS = `
     summary_status
   }
 `;
+function buildListFields(params) {
+  const includeSentences = params?.includeSentences === true;
+  const includeSummary = params?.includeSummary === true;
+  if (!includeSentences && !includeSummary) {
+    return TRANSCRIPT_LIST_FIELDS;
+  }
+  let fields = TRANSCRIPT_BASE_FIELDS;
+  if (includeSentences) {
+    fields += SENTENCES_FIELDS;
+  }
+  if (includeSummary) {
+    fields += SUMMARY_FIELDS;
+  }
+  return fields;
+}
 function createTranscriptsAPI(client) {
   return {
     async get(id, params) {
@@ -1600,6 +1981,7 @@ function createTranscriptsAPI(client) {
       return normalizeTranscript(data.transcript);
     },
     async list(params) {
+      const fields = buildListFields(params);
       const query = `
         query ListTranscripts(
           $keyword: String
@@ -1637,13 +2019,23 @@ function createTranscriptsAPI(client) {
             participant_email: $participant_email
             date: $date
           ) {
-            ${TRANSCRIPT_LIST_FIELDS}
+            ${fields}
           }
         }
       `;
+      let internalDomain;
+      if (params?.external) {
+        const userQuery = "query { user { email } }";
+        const userData = await client.execute(userQuery);
+        internalDomain = extractDomain(userData.user.email);
+      }
       const variables = buildListVariables(params);
       const data = await client.execute(query, variables);
-      return data.transcripts.map(normalizeTranscript);
+      let results = data.transcripts.map(normalizeTranscript);
+      if (internalDomain) {
+        results = results.filter((t) => hasExternalParticipants(t.participants, internalDomain));
+      }
+      return results;
     },
     async getSummary(id) {
       const query = `
@@ -1690,9 +2082,10 @@ function createTranscriptsAPI(client) {
       } = params;
       const transcripts = [];
       for await (const t of this.listAll({
+        ...listParams,
         keyword: query,
         scope,
-        ...listParams
+        includeSentences: true
       })) {
         transcripts.push(t);
         if (limit && transcripts.length >= limit) break;
@@ -1700,8 +2093,7 @@ function createTranscriptsAPI(client) {
       const allMatches = [];
       let transcriptsWithMatches = 0;
       for (const t of transcripts) {
-        const full = await this.get(t.id, { includeSentences: true });
-        const matches = searchTranscript(full, {
+        const matches = searchTranscript(t, {
           query,
           caseSensitive,
           speakers,
@@ -1753,13 +2145,13 @@ function createTranscriptsAPI(client) {
         organizers,
         participants,
         user_id,
-        channel_id
+        channel_id,
+        includeSentences: true
       })) {
         if (internalDomain && !hasExternalParticipants(t.participants, internalDomain)) {
           continue;
         }
-        const full = await this.get(t.id, { includeSentences: true, includeSummary: false });
-        transcripts.push(full);
+        transcripts.push(t);
         if (limit && transcripts.length >= limit) break;
       }
       return analyzeMeetings(transcripts, {
@@ -1777,13 +2169,20 @@ function createTranscriptsAPI(client) {
         toDate,
         mine,
         organizers,
-        participants
+        participants,
+        includeSummary: true
       })) {
-        const full = await this.get(t.id, { includeSentences: false, includeSummary: true });
-        transcripts.push(full);
+        transcripts.push(t);
         if (limit && transcripts.length >= limit) break;
       }
       return aggregateActionItems(transcripts, {}, filterOptions);
+    },
+    async bulkExport(params = {}) {
+      const { format = "markdown", asZip = false, onProgress } = params;
+      const transcriptIds = await collectTranscriptIds(client, this, params);
+      const files = await convertTranscripts(this, transcriptIds, format, onProgress);
+      const zip = asZip ? await createZipArchive(files) : void 0;
+      return { files, zip, format, totalExported: files.length };
     }
   };
 }
@@ -1862,6 +2261,50 @@ function buildListVariables(params) {
     date: params.date
   };
 }
+async function collectTranscriptIds(client, api, params) {
+  const { ids, fromDate, toDate, mine, organizers, participants, external, limit } = params;
+  if (ids?.length) {
+    return ids;
+  }
+  let internalDomain;
+  if (external) {
+    const userQuery = "query { user { email } }";
+    const userData = await client.execute(userQuery);
+    internalDomain = extractDomain(userData.user.email);
+  }
+  const result = [];
+  for await (const t of api.listAll({ fromDate, toDate, mine, organizers, participants })) {
+    if (internalDomain && !hasExternalParticipants(t.participants, internalDomain)) {
+      continue;
+    }
+    result.push(t.id);
+    if (limit && result.length >= limit) break;
+  }
+  return result;
+}
+async function convertTranscripts(api, transcriptIds, format, onProgress) {
+  const files = [];
+  const extension = format === "markdown" ? "md" : format;
+  let completed = 0;
+  const total = transcriptIds.length;
+  for await (const result of batch(
+    transcriptIds,
+    async (id) => {
+      const transcript = await api.get(id);
+      const content = await exportTranscript(transcript, format);
+      const filename = generateExportFilename(transcript, extension);
+      return { id, title: transcript.title, filename, content };
+    },
+    { delayMs: 100 }
+  )) {
+    if (!result.error) {
+      files.push(result.result);
+    }
+    completed++;
+    onProgress?.(completed, total);
+  }
+  return files;
+}
 
 // src/graphql/queries/users.ts
 var USER_FIELDS = `