fireflies-api 0.5.0

package/dist/cli/index.js

@@ -0,0 +1,3906 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { io } from 'socket.io-client';
+import { writeFile } from 'fs/promises';
+
+// src/cli/index.ts
+
+// src/errors.ts
+var FirefliesError = class extends Error {
+  code = "FIREFLIES_ERROR";
+  status;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "FirefliesError";
+    this.status = options?.status;
+  }
+};
+var AuthenticationError = class extends FirefliesError {
+  code = "AUTHENTICATION_ERROR";
+  constructor(message = "Invalid or missing API key") {
+    super(message, { status: 401 });
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends FirefliesError {
+  code = "RATE_LIMIT_ERROR";
+  /** Suggested wait time in milliseconds before retrying. */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, { status: 429 });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends FirefliesError {
+  code = "NOT_FOUND";
+  constructor(message = "Resource not found") {
+    super(message, { status: 404 });
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends FirefliesError {
+  code = "VALIDATION_ERROR";
+  constructor(message) {
+    super(message, { status: 400 });
+    this.name = "ValidationError";
+  }
+};
+var GraphQLError = class extends FirefliesError {
+  code = "GRAPHQL_ERROR";
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.name = "GraphQLError";
+    this.errors = errors;
+  }
+};
+var TimeoutError = class extends FirefliesError {
+  code = "TIMEOUT_ERROR";
+  constructor(message = "Request timed out") {
+    super(message, { status: 408 });
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends FirefliesError {
+  code = "NETWORK_ERROR";
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "NetworkError";
+  }
+};
+var RealtimeError = class extends FirefliesError {
+  code = "REALTIME_ERROR";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RealtimeError";
+  }
+};
+var ConnectionError = class extends RealtimeError {
+  code = "CONNECTION_ERROR";
+  constructor(message = "Failed to establish realtime connection", options) {
+    super(message, options);
+    this.name = "ConnectionError";
+  }
+};
+var StreamClosedError = class extends RealtimeError {
+  code = "STREAM_CLOSED";
+  constructor(message = "Stream has been closed") {
+    super(message);
+    this.name = "StreamClosedError";
+  }
+};
+function parseErrorResponse(status, body, defaultMessage) {
+  const message = extractErrorMessage(body) ?? defaultMessage;
+  switch (status) {
+    case 401:
+      return new AuthenticationError(message);
+    case 404:
+      return new NotFoundError(message);
+    case 429: {
+      const retryAfter = extractRetryAfter(body);
+      return new RateLimitError(message, retryAfter);
+    }
+    case 400:
+      return new ValidationError(message);
+    default:
+      return new FirefliesError(message, { status });
+  }
+}
+function extractErrorMessage(body) {
+  if (typeof body === "object" && body !== null) {
+    const obj = body;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "string") {
+      return obj.error;
+    }
+  }
+  return void 0;
+}
+function extractRetryAfter(body) {
+  if (typeof body === "object" && body !== null) {
+    const obj = body;
+    if (typeof obj.retryAfter === "number") {
+      return obj.retryAfter;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/rate-limit-tracker.ts
+var RATE_LIMIT_REMAINING_HEADER = "x-ratelimit-remaining-api";
+var RATE_LIMIT_LIMIT_HEADER = "x-ratelimit-limit-api";
+var RATE_LIMIT_RESET_HEADER = "x-ratelimit-reset-api";
+var RateLimitTracker = class {
+  _remaining;
+  _limit;
+  _resetInSeconds;
+  _updatedAt;
+  warningThreshold;
+  /**
+   * Create a new RateLimitTracker.
+   * @param warningThreshold - Threshold below which isLow returns true
+   */
+  constructor(warningThreshold = 10) {
+    this._remaining = void 0;
+    this._limit = void 0;
+    this._resetInSeconds = void 0;
+    this._updatedAt = 0;
+    this.warningThreshold = warningThreshold;
+  }
+  /**
+   * Get the current rate limit state.
+   */
+  get state() {
+    return {
+      remaining: this._remaining,
+      limit: this._limit,
+      resetInSeconds: this._resetInSeconds,
+      updatedAt: this._updatedAt
+    };
+  }
+  /**
+   * Check if remaining requests are below the warning threshold.
+   * Returns false if remaining is undefined (header not received).
+   */
+  get isLow() {
+    return this._remaining !== void 0 && this._remaining < this.warningThreshold;
+  }
+  /**
+   * Update state from response headers.
+   * Extracts x-ratelimit-remaining-api, x-ratelimit-limit-api, and x-ratelimit-reset-api headers.
+   *
+   * @param headers - Response headers (Headers object or plain object)
+   */
+  update(headers) {
+    const remaining = this.getHeader(headers, RATE_LIMIT_REMAINING_HEADER);
+    if (remaining !== null) {
+      const parsed = Number.parseInt(remaining, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._remaining = parsed;
+      }
+    }
+    const limit = this.getHeader(headers, RATE_LIMIT_LIMIT_HEADER);
+    if (limit !== null) {
+      const parsed = Number.parseInt(limit, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._limit = parsed;
+      }
+    }
+    const reset = this.getHeader(headers, RATE_LIMIT_RESET_HEADER);
+    if (reset !== null) {
+      const parsed = Number.parseInt(reset, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        this._resetInSeconds = parsed;
+      }
+    }
+    this._updatedAt = Date.now();
+  }
+  /**
+   * Reset the tracker to initial state.
+   */
+  reset() {
+    this._remaining = void 0;
+    this._limit = void 0;
+    this._resetInSeconds = void 0;
+    this._updatedAt = 0;
+  }
+  /**
+   * Calculate the delay to apply before the next request.
+   * Returns 0 if throttling is disabled or not needed.
+   *
+   * Uses linear interpolation: more delay as remaining approaches 0.
+   * - remaining >= startThreshold: no delay
+   * - remaining = 0: maxDelay
+   * - remaining in between: proportional delay
+   *
+   * @param config - Throttle configuration
+   * @returns Delay in milliseconds
+   */
+  getThrottleDelay(config) {
+    if (!config?.enabled) {
+      return 0;
+    }
+    if (this._remaining === void 0) {
+      return 0;
+    }
+    const startThreshold = Math.max(1, config.startThreshold ?? 20);
+    let minDelay = config.minDelay ?? 100;
+    let maxDelay = config.maxDelay ?? 2e3;
+    if (minDelay > maxDelay) {
+      [minDelay, maxDelay] = [maxDelay, minDelay];
+    }
+    if (this._remaining >= startThreshold) {
+      return 0;
+    }
+    if (this._remaining <= 0) {
+      return maxDelay;
+    }
+    const ratio = 1 - this._remaining / startThreshold;
+    return Math.round(minDelay + ratio * (maxDelay - minDelay));
+  }
+  /**
+   * Extract a header value from Headers object or plain object.
+   * For plain objects, performs case-insensitive key lookup.
+   */
+  getHeader(headers, name) {
+    if (headers instanceof Headers) {
+      return headers.get(name);
+    }
+    const lowerName = name.toLowerCase();
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === lowerName) {
+        return headers[key] ?? null;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4
+};
+async function retry(fn, options) {
+  const maxRetries = options?.maxRetries ?? DEFAULT_OPTIONS.maxRetries;
+  const baseDelay = options?.baseDelay ?? DEFAULT_OPTIONS.baseDelay;
+  const maxDelay = options?.maxDelay ?? DEFAULT_OPTIONS.maxDelay;
+  const shouldRetry = options?.shouldRetry ?? isRetryableError;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+      const delay = calculateDelay(error, attempt, baseDelay, maxDelay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function isRetryableError(error) {
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof TimeoutError) {
+    return true;
+  }
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof Error && "status" in error && typeof error.status === "number") {
+    return error.status >= 500 && error.status < 600;
+  }
+  return false;
+}
+function calculateDelay(error, attempt, baseDelay, maxDelay) {
+  if (error instanceof RateLimitError && error.retryAfter !== void 0) {
+    return Math.min(error.retryAfter, maxDelay);
+  }
+  const exponentialDelay = baseDelay * 2 ** attempt;
+  const jitter = Math.random() * 0.1 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/graphql/client.ts
+var DEFAULT_BASE_URL = "https://api.fireflies.ai/graphql";
+var DEFAULT_TIMEOUT = 3e4;
+var GraphQLClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  retryOptions;
+  rateLimitTracker;
+  rateLimitConfig;
+  lastWarningRemaining;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new FirefliesError("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    this.retryOptions = buildRetryOptions(config.retry);
+    if (config.rateLimit) {
+      const warningThreshold = config.rateLimit.warningThreshold ?? 10;
+      this.rateLimitTracker = new RateLimitTracker(warningThreshold);
+      this.rateLimitConfig = config.rateLimit;
+    } else {
+      this.rateLimitTracker = null;
+      this.rateLimitConfig = null;
+    }
+  }
+  /**
+   * Get the current rate limit state.
+   * Returns undefined if rate limit tracking is not configured.
+   */
+  get rateLimitState() {
+    return this.rateLimitTracker?.state;
+  }
+  /**
+   * Execute a GraphQL query or mutation.
+   *
+   * @param query - GraphQL query string
+   * @param variables - Optional query variables
+   * @returns The data from the GraphQL response
+   * @throws GraphQLError if the response contains errors
+   * @throws AuthenticationError if the API key is invalid
+   * @throws RateLimitError if rate limits are exceeded
+   */
+  async execute(query, variables) {
+    return retry(() => this.executeOnce(query, variables), this.retryOptions);
+  }
+  async executeOnce(query, variables) {
+    await this.applyThrottleDelay();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      this.updateRateLimitState(response.headers);
+      if (!response.ok) {
+        const body = await this.safeParseJson(response);
+        if (response.status === 429) {
+          const retryAfter = this.parseRetryAfter(response.headers);
+          this.invokeRateLimitedCallback(retryAfter);
+          throw parseErrorResponse(
+            response.status,
+            body,
+            `GraphQL request failed with status ${response.status}`
+          );
+        }
+        throw parseErrorResponse(
+          response.status,
+          body,
+          `GraphQL request failed with status ${response.status}`
+        );
+      }
+      const json = await response.json();
+      if (json.errors && json.errors.length > 0) {
+        throw this.parseGraphQLErrors(json.errors);
+      }
+      if (json.data === void 0) {
+        throw new FirefliesError("GraphQL response missing data field");
+      }
+      return json.data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof FirefliesError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new TimeoutError(`Request timed out after ${this.timeout}ms`);
+        }
+        throw new NetworkError(`Network request failed: ${error.message}`, error);
+      }
+      throw new NetworkError("Unknown network error occurred", error);
+    }
+  }
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Apply throttle delay before request if configured.
+   */
+  async applyThrottleDelay() {
+    if (!this.rateLimitTracker || !this.rateLimitConfig?.throttle) {
+      return;
+    }
+    const delay = this.rateLimitTracker.getThrottleDelay(this.rateLimitConfig.throttle);
+    if (delay > 0) {
+      await sleep2(delay);
+    }
+  }
+  /**
+   * Update rate limit state from response headers and invoke callbacks.
+   */
+  updateRateLimitState(headers) {
+    if (!this.rateLimitTracker || !this.rateLimitConfig) {
+      return;
+    }
+    const wasLow = this.rateLimitTracker.isLow;
+    this.rateLimitTracker.update(headers);
+    const state = this.rateLimitTracker.state;
+    this.safeCallback(() => this.rateLimitConfig?.onUpdate?.(state));
+    if (this.rateLimitTracker.isLow) {
+      const shouldWarn = !wasLow || // Just crossed threshold
+      state.remaining !== void 0 && this.lastWarningRemaining !== void 0 && state.remaining < this.lastWarningRemaining;
+      if (shouldWarn) {
+        this.lastWarningRemaining = state.remaining;
+        this.safeCallback(() => this.rateLimitConfig?.onWarning?.(state));
+      }
+    }
+  }
+  /**
+   * Parse Retry-After header value.
+   */
+  parseRetryAfter(headers) {
+    const value = headers.get("retry-after");
+    if (!value) return void 0;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  /**
+   * Invoke the onRateLimited callback.
+   */
+  invokeRateLimitedCallback(retryAfter) {
+    if (!this.rateLimitTracker || !this.rateLimitConfig?.onRateLimited) {
+      return;
+    }
+    const state = this.rateLimitTracker.state;
+    this.safeCallback(() => this.rateLimitConfig?.onRateLimited?.(state, retryAfter));
+  }
+  /**
+   * Safely invoke a callback, catching any errors to prevent user code from breaking the SDK.
+   */
+  safeCallback(fn) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+  parseGraphQLErrors(errors) {
+    const firstError = errors[0];
+    if (!firstError) {
+      return new GraphQLError("Unknown GraphQL error", errors);
+    }
+    const message = firstError.message;
+    if (message.toLowerCase().includes("unauthorized") || message.toLowerCase().includes("authentication")) {
+      return parseErrorResponse(401, { message }, message);
+    }
+    if (message.toLowerCase().includes("not found")) {
+      return parseErrorResponse(404, { message }, message);
+    }
+    return new GraphQLError(message, errors);
+  }
+};
+function buildRetryOptions(config) {
+  if (!config) {
+    return {};
+  }
+  return {
+    maxRetries: config.maxRetries,
+    baseDelay: config.baseDelay,
+    maxDelay: config.maxDelay
+  };
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/graphql/mutations/audio.ts
+function createAudioAPI(client) {
+  return {
+    async upload(params) {
+      const mutation = `
+        mutation UploadAudio($input: AudioUploadInput!) {
+          uploadAudio(input: $input) {
+            success
+            title
+            message
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        input: params
+      });
+      return data.uploadAudio;
+    }
+  };
+}
+
+// src/graphql/mutations/transcripts.ts
+function createTranscriptsMutationsAPI(client) {
+  return {
+    async delete(id) {
+      const mutation = `
+        mutation deleteTranscript($id: String!) {
+          deleteTranscript(id: $id) {
+            id
+            title
+            organizer_email
+            date
+            duration
+          }
+        }
+      `;
+      const data = await client.execute(mutation, { id });
+      return data.deleteTranscript;
+    }
+  };
+}
+
+// src/graphql/mutations/users.ts
+function createUsersMutationsAPI(client) {
+  return {
+    async setRole(userId, role) {
+      const mutation = `
+        mutation setUserRole($userId: String!, $role: Role!) {
+          setUserRole(user_id: $userId, role: $role) {
+            id
+            name
+            email
+            role
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        userId,
+        role
+      });
+      return data.setUserRole;
+    }
+  };
+}
+
+// src/helpers/pagination.ts
+async function* paginate(fetcher, pageSize = 50) {
+  let skip = 0;
+  let hasMore = true;
+  while (hasMore) {
+    const page = await fetcher(skip, pageSize);
+    for (const item of page) {
+      yield item;
+    }
+    if (page.length < pageSize) {
+      hasMore = false;
+    } else {
+      skip += pageSize;
+    }
+  }
+}
+
+// src/graphql/queries/ai-apps.ts
+var AI_APP_OUTPUT_FIELDS = `
+  transcript_id
+  user_id
+  app_id
+  created_at
+  title
+  prompt
+  response
+`;
+function createAIAppsAPI(client) {
+  return {
+    async list(params) {
+      const query = `
+        query GetAIAppsOutputs(
+          $appId: String
+          $transcriptId: String
+          $skip: Float
+          $limit: Float
+        ) {
+          apps(
+            app_id: $appId
+            transcript_id: $transcriptId
+            skip: $skip
+            limit: $limit
+          ) {
+            outputs { ${AI_APP_OUTPUT_FIELDS} }
+          }
+        }
+      `;
+      const data = await client.execute(query, {
+        appId: params?.app_id,
+        transcriptId: params?.transcript_id,
+        skip: params?.skip,
+        limit: params?.limit ?? 10
+      });
+      return data.apps.outputs;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 10);
+    }
+  };
+}
+
+// src/graphql/queries/bites.ts
+var BITE_FIELDS = `
+  id
+  transcript_id
+  user_id
+  name
+  status
+  summary
+  summary_status
+  media_type
+  start_time
+  end_time
+  created_at
+  thumbnail
+  preview
+  captions {
+    index
+    text
+    start_time
+    end_time
+    speaker_id
+    speaker_name
+  }
+  sources {
+    src
+    type
+  }
+  user {
+    id
+    name
+    first_name
+    last_name
+    picture
+  }
+  created_from {
+    id
+    name
+    type
+    description
+    duration
+  }
+  privacies
+`;
+function createBitesAPI(client) {
+  return {
+    async get(id) {
+      const query = `
+        query Bite($biteId: ID!) {
+          bite(id: $biteId) { ${BITE_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, { biteId: id });
+      return data.bite;
+    },
+    async list(params) {
+      const query = `
+        query Bites(
+          $transcriptId: ID
+          $mine: Boolean
+          $myTeam: Boolean
+          $limit: Int
+          $skip: Int
+        ) {
+          bites(
+            transcript_id: $transcriptId
+            mine: $mine
+            my_team: $myTeam
+            limit: $limit
+            skip: $skip
+          ) { ${BITE_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, {
+        transcriptId: params.transcript_id,
+        mine: params.mine,
+        myTeam: params.my_team,
+        limit: params.limit ?? 50,
+        skip: params.skip
+      });
+      return data.bites;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 50);
+    },
+    async create(params) {
+      const mutation = `
+        mutation CreateBite(
+          $transcriptId: ID!
+          $startTime: Float!
+          $endTime: Float!
+          $name: String
+          $mediaType: String
+          $summary: String
+          $privacies: [BitePrivacy!]
+        ) {
+          createBite(
+            transcript_Id: $transcriptId
+            start_time: $startTime
+            end_time: $endTime
+            name: $name
+            media_type: $mediaType
+            summary: $summary
+            privacies: $privacies
+          ) {
+            id
+            name
+            status
+            summary
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        transcriptId: params.transcript_id,
+        startTime: params.start_time,
+        endTime: params.end_time,
+        name: params.name,
+        mediaType: params.media_type,
+        summary: params.summary,
+        privacies: params.privacies
+      });
+      return data.createBite;
+    }
+  };
+}
+
+// src/graphql/queries/meetings.ts
+var ACTIVE_MEETING_FIELDS = `
+  id
+  title
+  organizer_email
+  meeting_link
+  start_time
+  end_time
+  privacy
+  state
+`;
+function createMeetingsAPI(client) {
+  return {
+    async active(params) {
+      const query = `
+        query ActiveMeetings($email: String, $states: [MeetingState!]) {
+          active_meetings(input: { email: $email, states: $states }) {
+            ${ACTIVE_MEETING_FIELDS}
+          }
+        }
+      `;
+      const data = await client.execute(query, {
+        email: params?.email,
+        states: params?.states
+      });
+      return data.active_meetings;
+    },
+    async addBot(params) {
+      const mutation = `
+        mutation AddToLiveMeeting(
+          $meetingLink: String!
+          $title: String
+          $meetingPassword: String
+          $duration: Int
+          $language: String
+        ) {
+          addToLiveMeeting(
+            meeting_link: $meetingLink
+            title: $title
+            meeting_password: $meetingPassword
+            duration: $duration
+            language: $language
+          ) {
+            success
+          }
+        }
+      `;
+      const data = await client.execute(mutation, {
+        meetingLink: params.meeting_link,
+        title: params.title,
+        meetingPassword: params.password,
+        duration: params.duration,
+        language: params.language
+      });
+      return data.addToLiveMeeting;
+    }
+  };
+}
+
+// src/helpers/action-items.ts
+var ASSIGNEE_PATTERNS = [
+  { pattern: /@(\w+)/i, group: 1 },
+  // @Alice
+  { pattern: /^(\w+):/i, group: 1 },
+  // Alice: at start
+  { pattern: /assigned to (\w+)/i, group: 1 },
+  // assigned to Alice
+  { pattern: /(\w+) will\b/i, group: 1 },
+  // Alice will
+  { pattern: /(\w+) to\b/i, group: 1 },
+  // Alice to (do something)
+  { pattern: /\s-\s*(\w+)$/i, group: 1 }
+  // ... - Alice
+];
+var DUE_DATE_PATTERNS = [
+  { pattern: /by (monday|tuesday|wednesday|thursday|friday|saturday|sunday)/i, group: 1 },
+  { pattern: /by (tomorrow|today)/i, group: 1 },
+  { pattern: /by (EOD|end of day)/i, group: 1 },
+  { pattern: /by (EOW|end of week)/i, group: 1 },
+  { pattern: /due (\d{4}-\d{2}-\d{2})/i, group: 1 },
+  { pattern: /due (jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d+/i, group: 0 },
+  { pattern: /by (\d{1,2}\/\d{1,2})/i, group: 1 }
+];
+var LIST_PREFIX_PATTERN = /^(?:[-•*]|\d+\.)\s*/;
+var SECTION_HEADER_PATTERN = /^\*\*(.+)\*\*$/;
+function extractActionItems(transcript, options = {}) {
+  const actionItemsText = transcript.summary?.action_items;
+  if (!actionItemsText || actionItemsText.trim().length === 0) {
+    return emptyResult();
+  }
+  const config = {
+    detectAssignees: options.detectAssignees ?? true,
+    detectDueDates: options.detectDueDates ?? true,
+    includeSourceSentences: options.includeSourceSentences ?? false,
+    participantNames: options.participantNames ?? []
+  };
+  const taskSentences = config.includeSourceSentences ? buildTaskSentenceLookup(transcript) : [];
+  const lines = actionItemsText.split(/\n/);
+  return parseAllLines(lines, config, taskSentences);
+}
+function parseAllLines(lines, config, taskSentences) {
+  const items = [];
+  const assigneeSet = /* @__PURE__ */ new Set();
+  let currentSectionAssignee;
+  for (let i = 0; i < lines.length; i++) {
+    const result = processLine(lines[i], i + 1, config, taskSentences, currentSectionAssignee);
+    if (result.type === "header") {
+      currentSectionAssignee = result.assignee;
+    } else if (result.type === "item" && result.item) {
+      items.push(result.item);
+      if (result.item.assignee) {
+        assigneeSet.add(result.item.assignee);
+      }
+    }
+  }
+  return buildResult(items, assigneeSet);
+}
+function processLine(line, lineNumber, config, taskSentences, sectionAssignee) {
+  if (!line) return { type: "skip" };
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return { type: "skip" };
+  const headerMatch = trimmed.match(SECTION_HEADER_PATTERN);
+  if (headerMatch?.[1]) {
+    const headerName = headerMatch[1];
+    const assignee = headerName.toLowerCase() === "unassigned" ? void 0 : headerName;
+    return { type: "header", assignee };
+  }
+  const item = parseLine(line, lineNumber, config, taskSentences, sectionAssignee);
+  if (item) {
+    return { type: "item", item };
+  }
+  return { type: "skip" };
+}
+function parseLine(line, lineNumber, config, taskSentences, sectionAssignee) {
+  if (!line) return null;
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  const text = trimmed.replace(LIST_PREFIX_PATTERN, "");
+  if (text.length === 0) return null;
+  const inlineAssignee = config.detectAssignees ? detectAssignee(text, config.participantNames) : void 0;
+  const assignee = inlineAssignee ?? sectionAssignee;
+  const dueDate = config.detectDueDates ? detectDueDate(text) : void 0;
+  const sourceSentence = config.includeSourceSentences ? findSourceSentence(text, taskSentences) : void 0;
+  return { text, assignee, dueDate, lineNumber, sourceSentence };
+}
+function buildResult(items, assigneeSet) {
+  return {
+    items,
+    totalItems: items.length,
+    assignedItems: items.filter((i) => i.assignee !== void 0).length,
+    datedItems: items.filter((i) => i.dueDate !== void 0).length,
+    assignees: Array.from(assigneeSet)
+  };
+}
+function emptyResult() {
+  return {
+    items: [],
+    totalItems: 0,
+    assignedItems: 0,
+    datedItems: 0,
+    assignees: []
+  };
+}
+function detectAssignee(text, participantNames) {
+  const participantSet = new Set(participantNames.map((n) => n.toLowerCase()));
+  const filterByParticipants = participantSet.size > 0;
+  for (const { pattern, group } of ASSIGNEE_PATTERNS) {
+    const match = text.match(pattern);
+    if (match?.[group]) {
+      const name = match[group];
+      if (filterByParticipants) {
+        if (participantSet.has(name.toLowerCase())) {
+          return name;
+        }
+        continue;
+      }
+      return name;
+    }
+  }
+  return void 0;
+}
+function detectDueDate(text) {
+  for (const { pattern, group } of DUE_DATE_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      if (group === 0 && match[0]) {
+        const fullMatch = match[0];
+        const dateMatch = fullMatch.match(
+          /(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d+/i
+        );
+        if (dateMatch?.[0]) {
+          return dateMatch[0];
+        }
+      }
+      if (match[group]) {
+        return match[group];
+      }
+    }
+  }
+  return void 0;
+}
+function buildTaskSentenceLookup(transcript) {
+  const sentences = transcript.sentences ?? [];
+  const result = [];
+  for (const sentence of sentences) {
+    const task = sentence.ai_filters?.task;
+    if (task) {
+      result.push({
+        text: sentence.text,
+        task: task.toLowerCase(),
+        speakerName: sentence.speaker_name,
+        startTime: Number.parseFloat(sentence.start_time)
+      });
+    }
+  }
+  return result;
+}
+function findSourceSentence(actionItemText, taskSentences) {
+  const normalizedItem = actionItemText.toLowerCase();
+  for (const sentence of taskSentences) {
+    if (normalizedItem.includes(sentence.task) || sentence.task.includes(normalizedItem)) {
+      return {
+        speakerName: sentence.speakerName,
+        text: sentence.text,
+        startTime: sentence.startTime
+      };
+    }
+    const itemWords = new Set(normalizedItem.split(/\s+/).filter((w) => w.length > 3));
+    const taskWords = sentence.task.split(/\s+/).filter((w) => w.length > 3);
+    const matchingWords = taskWords.filter((w) => itemWords.has(w));
+    if (taskWords.length > 0 && matchingWords.length / taskWords.length >= 0.5) {
+      return {
+        speakerName: sentence.speakerName,
+        text: sentence.text,
+        startTime: sentence.startTime
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/helpers/action-items-format.ts
+function filterActionItems(items, options) {
+  const { assignees, assignedOnly, datedOnly } = options;
+  const normalizedAssignees = assignees?.map((a) => a.toLowerCase());
+  return items.filter((item) => {
+    if (normalizedAssignees && normalizedAssignees.length > 0) {
+      if (!item.assignee) return false;
+      if (!normalizedAssignees.includes(item.assignee.toLowerCase())) return false;
+    }
+    if (assignedOnly && !item.assignee) {
+      return false;
+    }
+    if (datedOnly && !item.dueDate) {
+      return false;
+    }
+    return true;
+  });
+}
+function aggregateActionItems(transcripts, extractionOptions, filterOptions) {
+  if (transcripts.length === 0) {
+    return emptyAggregatedResult();
+  }
+  const allItems = [];
+  let transcriptsWithItems = 0;
+  for (const transcript of transcripts) {
+    const extracted = extractActionItems(transcript, extractionOptions);
+    if (extracted.items.length > 0) {
+      transcriptsWithItems++;
+      for (const item of extracted.items) {
+        allItems.push({
+          ...item,
+          transcriptId: transcript.id,
+          transcriptTitle: transcript.title,
+          transcriptDate: transcript.dateString
+        });
+      }
+    }
+  }
+  const filteredItems = filterOptions ? filterActionItems(allItems, filterOptions) : allItems;
+  return buildAggregatedResult(filteredItems, transcripts.length, transcriptsWithItems);
+}
+function emptyAggregatedResult() {
+  return {
+    items: [],
+    totalItems: 0,
+    transcriptsProcessed: 0,
+    transcriptsWithItems: 0,
+    assignedItems: 0,
+    datedItems: 0,
+    assignees: [],
+    dateRange: { earliest: "", latest: "" }
+  };
+}
+function buildAggregatedResult(items, transcriptsProcessed, transcriptsWithItems) {
+  const assigneeSet = /* @__PURE__ */ new Set();
+  let assignedItems = 0;
+  let datedItems = 0;
+  for (const item of items) {
+    if (item.assignee) {
+      assigneeSet.add(item.assignee);
+      assignedItems++;
+    }
+    if (item.dueDate) {
+      datedItems++;
+    }
+  }
+  const dates = items.map((i) => i.transcriptDate).filter(Boolean).sort();
+  return {
+    items,
+    totalItems: items.length,
+    transcriptsProcessed,
+    transcriptsWithItems,
+    assignedItems,
+    datedItems,
+    assignees: Array.from(assigneeSet),
+    dateRange: {
+      earliest: dates[0] ?? "",
+      latest: dates[dates.length - 1] ?? ""
+    }
+  };
+}
+function isAggregatedResult(result) {
+  return "transcriptsProcessed" in result;
+}
+function isAggregatedItem(item) {
+  return "transcriptId" in item;
+}
+function escapeMarkdown(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/#/g, "\\#").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/_/g, "\\_").replace(/`/g, "\\`");
+}
+function getPresetOptions(preset) {
+  switch (preset) {
+    case "notion":
+      return {
+        style: "checkbox",
+        includeAssignee: true,
+        includeDueDate: true
+      };
+    case "obsidian":
+      return {
+        style: "checkbox",
+        includeAssignee: false,
+        includeDueDate: true
+      };
+    case "github":
+      return {
+        style: "checkbox",
+        includeAssignee: true,
+        includeDueDate: true
+      };
+    default:
+      return {};
+  }
+}
+function formatItem(item, index, options) {
+  const { style, includeAssignee, includeDueDate, includeMeetingTitle } = options;
+  let prefix;
+  switch (style) {
+    case "bullet":
+      prefix = "-";
+      break;
+    case "numbered":
+      prefix = `${index + 1}.`;
+      break;
+    default:
+      prefix = "- [ ]";
+      break;
+  }
+  let text = escapeMarkdown(item.text);
+  const metadata = [];
+  if (includeAssignee && item.assignee) {
+    metadata.push(`@${item.assignee}`);
+  }
+  if (includeDueDate && item.dueDate) {
+    metadata.push(`due: ${item.dueDate}`);
+  }
+  if (includeMeetingTitle && isAggregatedItem(item)) {
+    metadata.push(`*${item.transcriptTitle}*`);
+  }
+  if (metadata.length > 0) {
+    text += ` (${metadata.join(", ")})`;
+  }
+  return `${prefix} ${text}`;
+}
+function groupBy(items, keyFn) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const group = groups.get(key);
+    if (group) {
+      group.push(item);
+    } else {
+      groups.set(key, [item]);
+    }
+  }
+  return groups;
+}
+function formatSummaryLine(result) {
+  return `**Summary:** ${result.totalItems} items from ${result.transcriptsProcessed} meetings (${result.assignedItems} assigned, ${result.datedItems} with due dates)`;
+}
+function sortGroupKeys(keys) {
+  return keys.sort((a, b) => {
+    if (a === "Unassigned") return 1;
+    if (b === "Unassigned") return -1;
+    return a.localeCompare(b);
+  });
+}
+function formatGroupedItems(result, groupByOption, itemOptions) {
+  const lines = [];
+  const keyFn = getGroupKeyFn(groupByOption);
+  const groups = groupBy(result.items, keyFn);
+  const sortedKeys = sortGroupKeys(Array.from(groups.keys()));
+  for (const key of sortedKeys) {
+    const groupItems = groups.get(key);
+    if (!groupItems) continue;
+    lines.push(`### ${key}`);
+    lines.push("");
+    groupItems.forEach((item, index) => {
+      lines.push(formatItem(item, index, itemOptions));
+    });
+    lines.push("");
+  }
+  return lines;
+}
+function formatFlatItems(items, itemOptions) {
+  return items.map((item, index) => formatItem(item, index, itemOptions));
+}
+function formatActionItemsMarkdown(result, options = {}) {
+  if (result.items.length === 0) {
+    return "";
+  }
+  const presetOptions = getPresetOptions(options.preset);
+  const mergedOptions = { ...presetOptions, ...options };
+  const {
+    style = "checkbox",
+    groupBy: groupByOption = "none",
+    includeAssignee = false,
+    includeDueDate = false,
+    includeMeetingTitle = false,
+    includeSummary = false
+  } = mergedOptions;
+  const lines = [];
+  if (includeSummary && isAggregatedResult(result)) {
+    lines.push(formatSummaryLine(result));
+    lines.push("");
+  }
+  const itemOptions = { style, includeAssignee, includeDueDate, includeMeetingTitle };
+  const shouldGroup = groupByOption !== "none" && isAggregatedResult(result);
+  if (shouldGroup) {
+    lines.push(...formatGroupedItems(result, groupByOption, itemOptions));
+  } else {
+    lines.push(...formatFlatItems(result.items, itemOptions));
+  }
+  return lines.join("\n").trim();
+}
+function getGroupKeyFn(groupBy2) {
+  switch (groupBy2) {
+    case "assignee":
+      return (item) => item.assignee ?? "Unassigned";
+    case "transcript":
+      return (item) => item.transcriptTitle;
+    case "date":
+      return (item) => item.transcriptDate;
+  }
+}
+
+// src/helpers/domain-utils.ts
+function extractDomain(email) {
+  const atIndex = email.indexOf("@");
+  if (atIndex < 0) return "";
+  const domain = email.slice(atIndex + 1).toLowerCase();
+  return domain || "";
+}
+function hasExternalParticipants(participants, internalDomain) {
+  const normalizedInternal = internalDomain.toLowerCase();
+  return participants.some((email) => {
+    const domain = extractDomain(email);
+    return domain !== "" && domain !== normalizedInternal;
+  });
+}
+
+// src/helpers/meeting-insights.ts
+function analyzeMeetings(transcripts, options = {}) {
+  const { speakers, groupBy: groupBy2, topSpeakersCount = 10, topParticipantsCount = 10 } = options;
+  if (transcripts.length === 0) {
+    return emptyInsights();
+  }
+  const totalDurationMinutes = sumDurations(transcripts);
+  const averageDurationMinutes = totalDurationMinutes / transcripts.length;
+  const byDayOfWeek = calculateDayOfWeekStats(transcripts);
+  const byTimeGroup = groupBy2 ? calculateTimeGroupStats(transcripts, groupBy2) : void 0;
+  const participantData = aggregateParticipants(transcripts);
+  const totalUniqueParticipants = participantData.uniqueEmails.size;
+  const averageParticipantsPerMeeting = calculateAverageParticipants(transcripts);
+  const topParticipants = buildTopParticipants(participantData.stats, topParticipantsCount);
+  const speakerData = aggregateSpeakers(transcripts, speakers);
+  const totalUniqueSpeakers = speakerData.uniqueNames.size;
+  const topSpeakers = buildTopSpeakers(speakerData.stats, topSpeakersCount);
+  const { earliestMeeting, latestMeeting } = findDateRange(transcripts);
+  return {
+    totalMeetings: transcripts.length,
+    totalDurationMinutes,
+    averageDurationMinutes,
+    byDayOfWeek,
+    byTimeGroup,
+    totalUniqueParticipants,
+    averageParticipantsPerMeeting,
+    topParticipants,
+    totalUniqueSpeakers,
+    topSpeakers,
+    earliestMeeting,
+    latestMeeting
+  };
+}
+function emptyInsights() {
+  return {
+    totalMeetings: 0,
+    totalDurationMinutes: 0,
+    averageDurationMinutes: 0,
+    byDayOfWeek: emptyDayOfWeekStats(),
+    byTimeGroup: void 0,
+    totalUniqueParticipants: 0,
+    averageParticipantsPerMeeting: 0,
+    topParticipants: [],
+    totalUniqueSpeakers: 0,
+    topSpeakers: [],
+    earliestMeeting: "",
+    latestMeeting: ""
+  };
+}
+function emptyDayOfWeekStats() {
+  const emptyDay = () => ({ count: 0, totalMinutes: 0 });
+  return {
+    monday: emptyDay(),
+    tuesday: emptyDay(),
+    wednesday: emptyDay(),
+    thursday: emptyDay(),
+    friday: emptyDay(),
+    saturday: emptyDay(),
+    sunday: emptyDay()
+  };
+}
+function sumDurations(transcripts) {
+  return transcripts.reduce((sum, t) => sum + (t.duration ?? 0), 0);
+}
+function calculateDayOfWeekStats(transcripts) {
+  const stats = emptyDayOfWeekStats();
+  const dayNames = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday"
+  ];
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    const dayIndex = date.getUTCDay();
+    const dayName = dayNames[dayIndex];
+    if (dayName) {
+      stats[dayName].count++;
+      stats[dayName].totalMinutes += t.duration ?? 0;
+    }
+  }
+  return stats;
+}
+function calculateTimeGroupStats(transcripts, groupBy2) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    const period = formatPeriod(date, groupBy2);
+    const existing = groups.get(period) ?? { count: 0, totalMinutes: 0 };
+    existing.count++;
+    existing.totalMinutes += t.duration ?? 0;
+    groups.set(period, existing);
+  }
+  const result = [];
+  for (const [period, data] of groups) {
+    result.push({
+      period,
+      count: data.count,
+      totalMinutes: data.totalMinutes,
+      averageMinutes: data.totalMinutes / data.count
+    });
+  }
+  result.sort((a, b) => a.period.localeCompare(b.period));
+  return result;
+}
+function formatPeriod(date, groupBy2) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  switch (groupBy2) {
+    case "day":
+      return `${year}-${month}-${day}`;
+    case "week":
+      return getISOWeek(date);
+    case "month":
+      return `${year}-${month}`;
+  }
+}
+function getISOWeek(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNumber = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getUTCFullYear()}-W${String(weekNumber).padStart(2, "0")}`;
+}
+function aggregateParticipants(transcripts) {
+  const uniqueEmails = /* @__PURE__ */ new Set();
+  const stats = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    const participants = t.participants ?? [];
+    const seenInMeeting = /* @__PURE__ */ new Set();
+    for (const email of participants) {
+      const normalizedEmail = email.toLowerCase();
+      uniqueEmails.add(normalizedEmail);
+      if (seenInMeeting.has(normalizedEmail)) continue;
+      seenInMeeting.add(normalizedEmail);
+      const existing = stats.get(normalizedEmail) ?? { meetingCount: 0, totalMinutes: 0 };
+      existing.meetingCount++;
+      existing.totalMinutes += t.duration ?? 0;
+      stats.set(normalizedEmail, existing);
+    }
+  }
+  return { uniqueEmails, stats };
+}
+function calculateAverageParticipants(transcripts) {
+  if (transcripts.length === 0) return 0;
+  let totalParticipants = 0;
+  for (const t of transcripts) {
+    const unique = new Set((t.participants ?? []).map((p) => p.toLowerCase()));
+    totalParticipants += unique.size;
+  }
+  return totalParticipants / transcripts.length;
+}
+function buildTopParticipants(stats, limit) {
+  const result = [];
+  for (const [email, data] of stats) {
+    result.push({
+      email,
+      meetingCount: data.meetingCount,
+      totalMinutes: data.totalMinutes
+    });
+  }
+  result.sort((a, b) => b.meetingCount - a.meetingCount);
+  return result.slice(0, limit);
+}
+function aggregateSpeakers(transcripts, filterSpeakers) {
+  const uniqueNames = /* @__PURE__ */ new Set();
+  const stats = /* @__PURE__ */ new Map();
+  const filterSet = filterSpeakers ? new Set(filterSpeakers) : null;
+  for (const t of transcripts) {
+    const sentences = t.sentences ?? [];
+    for (const sentence of sentences) {
+      const speakerName = sentence.speaker_name;
+      if (filterSet && !filterSet.has(speakerName)) continue;
+      uniqueNames.add(speakerName);
+      const existing = stats.get(speakerName) ?? {
+        meetingCount: 0,
+        totalTalkTimeSeconds: 0,
+        meetings: /* @__PURE__ */ new Set()
+      };
+      const duration = parseSentenceDuration(sentence);
+      existing.totalTalkTimeSeconds += duration;
+      if (!existing.meetings.has(t.id)) {
+        existing.meetings.add(t.id);
+        existing.meetingCount++;
+      }
+      stats.set(speakerName, existing);
+    }
+  }
+  return { uniqueNames, stats };
+}
+function parseSentenceDuration(sentence) {
+  const start = Number.parseFloat(sentence.start_time);
+  const end = Number.parseFloat(sentence.end_time);
+  return Math.max(0, end - start);
+}
+function buildTopSpeakers(stats, limit) {
+  const result = [];
+  for (const [name, data] of stats) {
+    result.push({
+      name,
+      meetingCount: data.meetingCount,
+      totalTalkTimeSeconds: data.totalTalkTimeSeconds,
+      averageTalkTimeSeconds: data.meetingCount > 0 ? data.totalTalkTimeSeconds / data.meetingCount : 0
+    });
+  }
+  result.sort((a, b) => b.totalTalkTimeSeconds - a.totalTalkTimeSeconds);
+  return result.slice(0, limit);
+}
+function findDateRange(transcripts) {
+  let earliest = null;
+  let latest = null;
+  for (const t of transcripts) {
+    const date = parseDate(t.dateString);
+    if (!date) continue;
+    if (!earliest || date < earliest) {
+      earliest = date;
+    }
+    if (!latest || date > latest) {
+      latest = date;
+    }
+  }
+  return {
+    earliestMeeting: earliest ? formatDateOnly(earliest) : "",
+    latestMeeting: latest ? formatDateOnly(latest) : ""
+  };
+}
+function parseDate(dateString) {
+  if (!dateString) return null;
+  const date = new Date(dateString);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function formatDateOnly(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/helpers/search.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchesSpeaker(sentence, speakerSet) {
+  if (!speakerSet) return true;
+  return speakerSet.has(sentence.speaker_name.toLowerCase());
+}
+function matchesAIFilters(sentence, filterQuestions, filterTasks) {
+  if (!filterQuestions && !filterTasks) return true;
+  const hasQuestion = Boolean(sentence.ai_filters?.question);
+  const hasTask = Boolean(sentence.ai_filters?.task);
+  if (filterQuestions && filterTasks) {
+    return hasQuestion || hasTask;
+  }
+  if (filterQuestions) return hasQuestion;
+  if (filterTasks) return hasTask;
+  return true;
+}
+function extractContext(sentences, index, contextLines) {
+  const beforeStart = Math.max(0, index - contextLines);
+  const afterEnd = Math.min(sentences.length, index + contextLines + 1);
+  return {
+    before: sentences.slice(beforeStart, index).map((s) => ({
+      speakerName: s.speaker_name,
+      text: s.text
+    })),
+    after: sentences.slice(index + 1, afterEnd).map((s) => ({
+      speakerName: s.speaker_name,
+      text: s.text
+    }))
+  };
+}
+function sentenceToMatch(sentence, transcript, context) {
+  return {
+    transcriptId: transcript.id,
+    transcriptTitle: transcript.title,
+    transcriptDate: transcript.dateString,
+    transcriptUrl: transcript.transcript_url,
+    sentence: {
+      index: sentence.index,
+      text: sentence.text,
+      speakerName: sentence.speaker_name,
+      startTime: Number.parseFloat(sentence.start_time),
+      endTime: Number.parseFloat(sentence.end_time),
+      isQuestion: Boolean(sentence.ai_filters?.question),
+      isTask: Boolean(sentence.ai_filters?.task)
+    },
+    context
+  };
+}
+function searchTranscript(transcript, options) {
+  const {
+    query,
+    caseSensitive = false,
+    speakers,
+    filterQuestions = false,
+    filterTasks = false,
+    contextLines = 1
+  } = options;
+  if (!query || query.trim() === "") {
+    return [];
+  }
+  const sentences = transcript.sentences ?? [];
+  if (sentences.length === 0) {
+    return [];
+  }
+  const escapedQuery = escapeRegex(query);
+  const regex = new RegExp(escapedQuery, caseSensitive ? "" : "i");
+  const speakerSet = speakers ? new Set(speakers.map((s) => s.toLowerCase())) : null;
+  const matches = [];
+  for (let i = 0; i < sentences.length; i++) {
+    const sentence = sentences[i];
+    if (!sentence) continue;
+    if (!regex.test(sentence.text)) continue;
+    if (!matchesSpeaker(sentence, speakerSet)) continue;
+    if (!matchesAIFilters(sentence, filterQuestions, filterTasks)) continue;
+    const context = extractContext(sentences, i, contextLines);
+    matches.push(sentenceToMatch(sentence, transcript, context));
+  }
+  return matches;
+}
+
+// src/graphql/queries/transcripts.ts
+var TRANSCRIPT_BASE_FIELDS = `
+  id
+  title
+  organizer_email
+  host_email
+  user {
+    user_id
+    email
+    name
+  }
+  speakers {
+    id
+    name
+  }
+  transcript_url
+  participants
+  meeting_attendees {
+    displayName
+    email
+    phoneNumber
+    name
+    location
+  }
+  meeting_attendance {
+    name
+    join_time
+    leave_time
+  }
+  fireflies_users
+  workspace_users
+  duration
+  dateString
+  date
+  audio_url
+  video_url
+  calendar_id
+  meeting_info {
+    fred_joined
+    silent_meeting
+    summary_status
+  }
+  cal_id
+  calendar_type
+  apps_preview {
+    outputs {
+      transcript_id
+      user_id
+      app_id
+      created_at
+      title
+      prompt
+      response
+    }
+  }
+  meeting_link
+  analytics {
+    sentiments {
+      negative_pct
+      neutral_pct
+      positive_pct
+    }
+  }
+  channels {
+    id
+    title
+    is_private
+    created_at
+    updated_at
+    created_by
+    members {
+      user_id
+      email
+      name
+    }
+  }
+`;
+var SENTENCES_FIELDS = `
+  sentences {
+    index
+    text
+    raw_text
+    start_time
+    end_time
+    speaker_id
+    speaker_name
+    ai_filters {
+      task
+      pricing
+      metric
+      question
+      date_and_time
+      text_cleanup
+      sentiment
+    }
+  }
+`;
+var SUMMARY_FIELDS = `
+  summary {
+    action_items
+    keywords
+    outline
+    overview
+    shorthand_bullet
+    notes
+    gist
+    bullet_gist
+    short_summary
+    short_overview
+    meeting_type
+    topics_discussed
+    transcript_chapters
+    extended_sections {
+      title
+      content
+    }
+  }
+`;
+function buildTranscriptFields(params) {
+  const includeSentences = params?.includeSentences !== false;
+  const includeSummary = params?.includeSummary !== false;
+  let fields = TRANSCRIPT_BASE_FIELDS;
+  if (includeSentences) {
+    fields += SENTENCES_FIELDS;
+  }
+  if (includeSummary) {
+    fields += SUMMARY_FIELDS;
+  }
+  return fields;
+}
+var TRANSCRIPT_LIST_FIELDS = `
+  id
+  title
+  organizer_email
+  transcript_url
+  participants
+  duration
+  dateString
+  date
+  video_url
+  meeting_info {
+    fred_joined
+    silent_meeting
+    summary_status
+  }
+`;
+function createTranscriptsAPI(client) {
+  return {
+    async get(id, params) {
+      const fields = buildTranscriptFields(params);
+      const query = `
+        query GetTranscript($id: String!) {
+          transcript(id: $id) {
+            ${fields}
+          }
+        }
+      `;
+      const data = await client.execute(query, { id });
+      return normalizeTranscript(data.transcript);
+    },
+    async list(params) {
+      const query = `
+        query ListTranscripts(
+          $keyword: String
+          $scope: String
+          $organizers: [String!]
+          $participants: [String!]
+          $user_id: String
+          $mine: Boolean
+          $channel_id: String
+          $fromDate: DateTime
+          $toDate: DateTime
+          $limit: Int
+          $skip: Int
+          $title: String
+          $host_email: String
+          $organizer_email: String
+          $participant_email: String
+          $date: Float
+        ) {
+          transcripts(
+            keyword: $keyword
+            scope: $scope
+            organizers: $organizers
+            participants: $participants
+            user_id: $user_id
+            mine: $mine
+            channel_id: $channel_id
+            fromDate: $fromDate
+            toDate: $toDate
+            limit: $limit
+            skip: $skip
+            title: $title
+            host_email: $host_email
+            organizer_email: $organizer_email
+            participant_email: $participant_email
+            date: $date
+          ) {
+            ${TRANSCRIPT_LIST_FIELDS}
+          }
+        }
+      `;
+      const variables = buildListVariables(params);
+      const data = await client.execute(query, variables);
+      return data.transcripts.map(normalizeTranscript);
+    },
+    async getSummary(id) {
+      const query = `
+        query GetTranscriptSummary($id: String!) {
+          transcript(id: $id) {
+            summary {
+              action_items
+              keywords
+              outline
+              overview
+              shorthand_bullet
+              notes
+              gist
+              bullet_gist
+              short_summary
+              short_overview
+              meeting_type
+              topics_discussed
+              transcript_chapters
+              extended_sections {
+                title
+                content
+              }
+            }
+          }
+        }
+      `;
+      const data = await client.execute(query, { id });
+      return data.transcript.summary;
+    },
+    listAll(params) {
+      return paginate((skip, limit) => this.list({ ...params, skip, limit }), 50);
+    },
+    async search(query, params = {}) {
+      const {
+        caseSensitive = false,
+        scope = "sentences",
+        speakers,
+        filterQuestions,
+        filterTasks,
+        contextLines = 1,
+        limit,
+        ...listParams
+      } = params;
+      const transcripts = [];
+      for await (const t of this.listAll({
+        keyword: query,
+        scope,
+        ...listParams
+      })) {
+        transcripts.push(t);
+        if (limit && transcripts.length >= limit) break;
+      }
+      const allMatches = [];
+      let transcriptsWithMatches = 0;
+      for (const t of transcripts) {
+        const full = await this.get(t.id, { includeSentences: true });
+        const matches = searchTranscript(full, {
+          query,
+          caseSensitive,
+          speakers,
+          filterQuestions,
+          filterTasks,
+          contextLines
+        });
+        if (matches.length > 0) {
+          transcriptsWithMatches++;
+          allMatches.push(...matches);
+        }
+      }
+      return {
+        query,
+        options: params,
+        totalMatches: allMatches.length,
+        transcriptsSearched: transcripts.length,
+        transcriptsWithMatches,
+        matches: allMatches
+      };
+    },
+    async insights(params = {}) {
+      const {
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants,
+        user_id,
+        channel_id,
+        limit,
+        external,
+        speakers,
+        groupBy: groupBy2,
+        topSpeakersCount,
+        topParticipantsCount
+      } = params;
+      let internalDomain;
+      if (external) {
+        const userQuery = "query { user { email } }";
+        const userData = await client.execute(userQuery);
+        internalDomain = extractDomain(userData.user.email);
+      }
+      const transcripts = [];
+      for await (const t of this.listAll({
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants,
+        user_id,
+        channel_id
+      })) {
+        if (internalDomain && !hasExternalParticipants(t.participants, internalDomain)) {
+          continue;
+        }
+        const full = await this.get(t.id, { includeSentences: true, includeSummary: false });
+        transcripts.push(full);
+        if (limit && transcripts.length >= limit) break;
+      }
+      return analyzeMeetings(transcripts, {
+        speakers,
+        groupBy: groupBy2,
+        topSpeakersCount,
+        topParticipantsCount
+      });
+    },
+    async exportActionItems(params = {}) {
+      const { fromDate, toDate, mine, organizers, participants, limit, filterOptions } = params;
+      const transcripts = [];
+      for await (const t of this.listAll({
+        fromDate,
+        toDate,
+        mine,
+        organizers,
+        participants
+      })) {
+        const full = await this.get(t.id, { includeSentences: false, includeSummary: true });
+        transcripts.push(full);
+        if (limit && transcripts.length >= limit) break;
+      }
+      return aggregateActionItems(transcripts, {}, filterOptions);
+    }
+  };
+}
+function orUndefined(value) {
+  return value ?? void 0;
+}
+function orEmptyArray(value) {
+  return value ?? [];
+}
+function normalizeRequiredFields(raw) {
+  return {
+    id: raw.id,
+    title: raw.title ?? "",
+    organizer_email: raw.organizer_email ?? "",
+    transcript_url: raw.transcript_url ?? "",
+    duration: raw.duration ?? 0,
+    dateString: raw.dateString ?? "",
+    date: raw.date ?? 0
+  };
+}
+function normalizeArrayFields(raw) {
+  return {
+    speakers: orEmptyArray(raw.speakers),
+    participants: orEmptyArray(raw.participants),
+    meeting_attendees: orEmptyArray(raw.meeting_attendees),
+    meeting_attendance: orEmptyArray(raw.meeting_attendance),
+    fireflies_users: orEmptyArray(raw.fireflies_users),
+    workspace_users: orEmptyArray(raw.workspace_users),
+    sentences: orEmptyArray(raw.sentences),
+    channels: orEmptyArray(raw.channels)
+  };
+}
+function normalizeOptionalFields(raw) {
+  return {
+    host_email: orUndefined(raw.host_email),
+    user: orUndefined(raw.user),
+    audio_url: orUndefined(raw.audio_url),
+    video_url: orUndefined(raw.video_url),
+    calendar_id: orUndefined(raw.calendar_id),
+    summary: orUndefined(raw.summary),
+    meeting_info: orUndefined(raw.meeting_info),
+    cal_id: orUndefined(raw.cal_id),
+    calendar_type: orUndefined(raw.calendar_type),
+    apps_preview: orUndefined(raw.apps_preview),
+    meeting_link: orUndefined(raw.meeting_link),
+    analytics: orUndefined(raw.analytics)
+  };
+}
+function normalizeTranscript(raw) {
+  return {
+    ...normalizeRequiredFields(raw),
+    ...normalizeArrayFields(raw),
+    ...normalizeOptionalFields(raw)
+  };
+}
+function buildListVariables(params) {
+  if (!params) {
+    return { limit: 50 };
+  }
+  return {
+    keyword: params.keyword,
+    scope: params.scope,
+    organizers: params.organizers,
+    participants: params.participants,
+    user_id: params.user_id,
+    mine: params.mine,
+    channel_id: params.channel_id,
+    fromDate: params.fromDate,
+    toDate: params.toDate,
+    limit: params.limit ?? 50,
+    skip: params.skip,
+    title: params.title,
+    host_email: params.host_email,
+    organizer_email: params.organizer_email,
+    participant_email: params.participant_email,
+    date: params.date
+  };
+}
+
+// src/graphql/queries/users.ts
+var USER_FIELDS = `
+  user_id
+  email
+  name
+  num_transcripts
+  recent_meeting
+  recent_transcript
+  minutes_consumed
+  is_admin
+  integrations
+  user_groups {
+    id
+    name
+    handle
+    members {
+      user_id
+      email
+    }
+  }
+`;
+function createUsersAPI(client) {
+  return {
+    async me() {
+      const query = `query { user { ${USER_FIELDS} } }`;
+      const data = await client.execute(query);
+      return data.user;
+    },
+    async get(id) {
+      const query = `
+        query User($userId: String!) {
+          user(id: $userId) { ${USER_FIELDS} }
+        }
+      `;
+      const data = await client.execute(query, { userId: id });
+      return data.user;
+    },
+    async list() {
+      const query = `query Users { users { ${USER_FIELDS} } }`;
+      const data = await client.execute(query);
+      return data.users;
+    }
+  };
+}
+var DEFAULT_WS_URL = "wss://api.fireflies.ai";
+var DEFAULT_WS_PATH = "/ws/realtime";
+var DEFAULT_TIMEOUT2 = 2e4;
+var DEFAULT_CHUNK_TIMEOUT = 2e4;
+var DEFAULT_RECONNECT_DELAY = 5e3;
+var DEFAULT_MAX_RECONNECT_DELAY = 6e4;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var RealtimeConnection = class {
+  socket = null;
+  config;
+  constructor(config) {
+    this.config = {
+      wsUrl: DEFAULT_WS_URL,
+      wsPath: DEFAULT_WS_PATH,
+      timeout: DEFAULT_TIMEOUT2,
+      chunkTimeout: DEFAULT_CHUNK_TIMEOUT,
+      reconnect: true,
+      maxReconnectAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
+      reconnectDelay: DEFAULT_RECONNECT_DELAY,
+      maxReconnectDelay: DEFAULT_MAX_RECONNECT_DELAY,
+      ...config
+    };
+  }
+  /**
+   * Establish connection and wait for auth success.
+   */
+  async connect() {
+    if (this.socket?.connected) {
+      return;
+    }
+    const socket = io(this.config.wsUrl, {
+      path: this.config.wsPath,
+      auth: {
+        token: `Bearer ${this.config.apiKey}`,
+        transcriptId: this.config.transcriptId
+      },
+      // Force WebSocket transport (proven more reliable than polling)
+      transports: ["websocket"],
+      reconnection: this.config.reconnect,
+      reconnectionDelay: this.config.reconnectDelay,
+      reconnectionDelayMax: this.config.maxReconnectDelay,
+      reconnectionAttempts: this.config.maxReconnectAttempts,
+      // Exponential backoff factor (default 2x matches our fireflies-whiteboard pattern)
+      randomizationFactor: 0.5,
+      timeout: this.config.timeout,
+      autoConnect: false
+    });
+    this.socket = socket;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        socket.disconnect();
+        reject(new TimeoutError(`Realtime connection timed out after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      const cleanup = () => clearTimeout(timeoutId);
+      socket.once("auth.success", () => {
+        cleanup();
+        resolve();
+      });
+      socket.once("auth.failed", (data) => {
+        cleanup();
+        socket.disconnect();
+        reject(new AuthenticationError(`Realtime auth failed: ${formatData(data)}`));
+      });
+      socket.once("connection.error", (data) => {
+        cleanup();
+        socket.disconnect();
+        reject(new ConnectionError(`Realtime connection error: ${formatData(data)}`));
+      });
+      socket.once("connect_error", (error) => {
+        cleanup();
+        socket.disconnect();
+        const message = error.message || "Connection failed";
+        if (message.includes("auth") || message.includes("401") || message.includes("unauthorized")) {
+          reject(new AuthenticationError(`Realtime auth failed: ${message}`));
+        } else {
+          reject(
+            new ConnectionError(`Realtime connection failed: ${message}`, {
+              cause: error
+            })
+          );
+        }
+      });
+      socket.connect();
+    });
+  }
+  /**
+   * Register a chunk handler.
+   * Handles both { payload: {...} } and direct payload shapes.
+   */
+  onChunk(handler) {
+    this.socket?.on("transcription.broadcast", (data) => {
+      const chunk = "payload" in data ? data.payload : data;
+      handler(chunk);
+    });
+  }
+  /**
+   * Register a disconnect handler.
+   */
+  onDisconnect(handler) {
+    this.socket?.on("disconnect", handler);
+  }
+  /**
+   * Register a reconnect handler.
+   */
+  onReconnect(handler) {
+    this.socket?.io.on("reconnect", handler);
+  }
+  /**
+   * Register a reconnect attempt handler.
+   */
+  onReconnectAttempt(handler) {
+    this.socket?.io.on("reconnect_attempt", handler);
+  }
+  /**
+   * Register an error handler.
+   */
+  onError(handler) {
+    this.socket?.on("connect_error", handler);
+  }
+  /**
+   * Disconnect and cleanup.
+   */
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  get connected() {
+    return this.socket?.connected ?? false;
+  }
+};
+function formatData(data) {
+  if (data === void 0 || data === null) {
+    return String(data);
+  }
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return String(data);
+  }
+}
+
+// src/realtime/stream.ts
+var RealtimeStream = class {
+  connection;
+  listeners = /* @__PURE__ */ new Map();
+  buffer = [];
+  waiters = [];
+  closed = false;
+  lastChunkId = null;
+  lastChunk = null;
+  constructor(config) {
+    this.connection = new RealtimeConnection(config);
+  }
+  /**
+   * Connect to the realtime stream.
+   * @throws AuthenticationError if authentication fails
+   * @throws ConnectionError if connection fails
+   * @throws TimeoutError if connection times out
+   */
+  async connect() {
+    await this.connection.connect();
+    this.setupHandlers();
+    this.emit("connected");
+  }
+  setupHandlers() {
+    this.connection.onChunk((rawChunk) => {
+      const isNewChunk = this.lastChunkId !== null && rawChunk.chunk_id !== this.lastChunkId;
+      if (isNewChunk && this.lastChunk) {
+        const finalChunk = { ...this.lastChunk, isFinal: true };
+        this.emitChunk(finalChunk);
+      }
+      const chunk = { ...rawChunk, isFinal: false };
+      this.lastChunkId = chunk.chunk_id;
+      this.lastChunk = chunk;
+      this.emit("chunk", chunk);
+    });
+    this.connection.onDisconnect((reason) => {
+      if (this.lastChunk) {
+        const finalChunk = { ...this.lastChunk, isFinal: true };
+        this.emitChunk(finalChunk);
+        this.lastChunk = null;
+      }
+      this.emit("disconnected", reason);
+      if (!this.connection.connected) {
+        this.closed = true;
+        for (const waiter of this.waiters) {
+          waiter(null);
+        }
+        this.waiters = [];
+      }
+    });
+    this.connection.onReconnectAttempt((attempt) => {
+      this.emit("reconnecting", attempt);
+    });
+    this.connection.onReconnect(() => {
+      this.emit("connected");
+    });
+    this.connection.onError((error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+   * Register an event listener.
+   * @param event - Event name
+   * @param handler - Event handler
+   */
+  on(event, handler) {
+    let handlers = this.listeners.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.listeners.set(event, handlers);
+    }
+    handlers.add(handler);
+    return this;
+  }
+  /**
+   * Remove an event listener.
+   * @param event - Event name
+   * @param handler - Event handler to remove
+   */
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+    return this;
+  }
+  /**
+   * Emit a chunk to both event listeners and async iterator buffer.
+   * Used for final chunks that should be yielded by the iterator.
+   */
+  emitChunk(chunk) {
+    this.emit("chunk", chunk);
+    if (chunk.isFinal) {
+      if (this.waiters.length > 0) {
+        const waiter = this.waiters.shift();
+        waiter?.(chunk);
+      } else {
+        this.buffer.push(chunk);
+      }
+    }
+  }
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    handlers?.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch {
+      }
+    });
+  }
+  /**
+   * AsyncIterable implementation for `for await` loops.
+   */
+  async *[Symbol.asyncIterator]() {
+    if (this.closed) {
+      throw new StreamClosedError();
+    }
+    while (!this.closed) {
+      const buffered = this.buffer.shift();
+      if (buffered) {
+        yield buffered;
+        continue;
+      }
+      const chunk = await new Promise((resolve) => {
+        if (this.closed) {
+          resolve(null);
+          return;
+        }
+        this.waiters.push(resolve);
+      });
+      if (chunk === null) {
+        break;
+      }
+      yield chunk;
+    }
+  }
+  /**
+   * Close the stream and disconnect.
+   */
+  close() {
+    if (this.lastChunk) {
+      const finalChunk = { ...this.lastChunk, isFinal: true };
+      this.emitChunk(finalChunk);
+      this.lastChunk = null;
+    }
+    this.closed = true;
+    this.connection.disconnect();
+    this.buffer = [];
+    this.lastChunkId = null;
+    for (const waiter of this.waiters) {
+      waiter(null);
+    }
+    this.waiters = [];
+  }
+  /**
+   * Whether the stream is currently connected.
+   */
+  get connected() {
+    return this.connection.connected;
+  }
+};
+
+// src/realtime/api.ts
+function createRealtimeAPI(apiKey, baseConfig) {
+  return {
+    async connect(transcriptId) {
+      const stream = new RealtimeStream({
+        apiKey,
+        transcriptId,
+        ...baseConfig
+      });
+      await stream.connect();
+      return stream;
+    },
+    async *stream(transcriptId) {
+      const stream = new RealtimeStream({
+        apiKey,
+        transcriptId,
+        ...baseConfig
+      });
+      try {
+        await stream.connect();
+        yield* stream;
+      } finally {
+        stream.close();
+      }
+    }
+  };
+}
+
+// src/client.ts
+var FirefliesClient = class {
+  graphql;
+  /**
+   * Transcript operations: list, get, search, delete.
+   */
+  transcripts;
+  /**
+   * User operations: me, get, list, setRole.
+   */
+  users;
+  /**
+   * Bite operations: get, list, create.
+   */
+  bites;
+  /**
+   * Meeting operations: active meetings, add bot.
+   */
+  meetings;
+  /**
+   * Audio operations: upload audio for transcription.
+   */
+  audio;
+  /**
+   * AI Apps operations: list outputs.
+   */
+  aiApps;
+  /**
+   * Realtime transcription streaming.
+   */
+  realtime;
+  /**
+   * Create a new Fireflies client.
+   *
+   * @param config - Client configuration
+   * @throws FirefliesError if API key is missing
+   */
+  constructor(config) {
+    this.graphql = new GraphQLClient(config);
+    const transcriptsQueries = createTranscriptsAPI(this.graphql);
+    const transcriptsMutations = createTranscriptsMutationsAPI(this.graphql);
+    this.transcripts = { ...transcriptsQueries, ...transcriptsMutations };
+    const usersQueries = createUsersAPI(this.graphql);
+    const usersMutations = createUsersMutationsAPI(this.graphql);
+    this.users = { ...usersQueries, ...usersMutations };
+    this.bites = createBitesAPI(this.graphql);
+    this.meetings = createMeetingsAPI(this.graphql);
+    this.audio = createAudioAPI(this.graphql);
+    this.aiApps = createAIAppsAPI(this.graphql);
+    this.realtime = createRealtimeAPI(config.apiKey);
+  }
+  /**
+   * Get the current rate limit state.
+   * Returns undefined if rate limit tracking is not configured.
+   *
+   * @example
+   * ```typescript
+   * const client = new FirefliesClient({
+   *   apiKey: '...',
+   *   rateLimit: { warningThreshold: 10 }
+   * });
+   *
+   * await client.users.me();
+   * console.log(client.rateLimits);
+   * // { remaining: 59, limit: 60, resetInSeconds: 60, updatedAt: 1706299500000 }
+   * ```
+   */
+  get rateLimits() {
+    return this.graphql.rateLimitState;
+  }
+};
+
+// src/cli/utils/client.ts
+function getClient(cmd) {
+  const opts = cmd.optsWithGlobals();
+  const apiKey = opts.apiKey ?? process.env["FIREFLIES_API_KEY"];
+  if (!apiKey) {
+    console.error("Error: API key required. Set FIREFLIES_API_KEY or use --api-key");
+    process.exit(1);
+  }
+  return new FirefliesClient({ apiKey });
+}
+function getOutputFormat(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return opts.output ?? "json";
+}
+
+// src/cli/utils/error.ts
+function handleError(error) {
+  if (error instanceof AuthenticationError) {
+    console.error("Authentication failed: Check your API key");
+    process.exit(1);
+  }
+  if (error instanceof NotFoundError) {
+    console.error(`Not found: ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof RateLimitError) {
+    console.error(`Rate limited: ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof ValidationError) {
+    console.error(`Validation error: ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof FirefliesError) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  console.error("An unexpected error occurred");
+  process.exit(1);
+}
+function withErrorHandling(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      handleError(error);
+    }
+  };
+}
+
+// src/cli/utils/output.ts
+function writeLine(line) {
+  process.stdout.write(`${line}
+`);
+}
+function outputLine(data) {
+  writeLine(JSON.stringify(data));
+}
+function output(data, format) {
+  switch (format) {
+    case "json":
+      console.log(JSON.stringify(data, null, 2));
+      break;
+    case "jsonl":
+      if (Array.isArray(data)) {
+        for (const item of data) {
+          writeLine(JSON.stringify(item));
+        }
+      } else {
+        writeLine(JSON.stringify(data));
+      }
+      break;
+    case "tsv":
+      printTsv(data);
+      break;
+    case "table":
+      if (Array.isArray(data)) {
+        printTable(data);
+      } else if (data && typeof data === "object") {
+        printKeyValue(data);
+      } else {
+        console.log(data);
+      }
+      break;
+    case "plain":
+      if (typeof data === "string") {
+        console.log(data);
+      } else {
+        console.log(JSON.stringify(data));
+      }
+      break;
+  }
+}
+function printTable(rows) {
+  if (rows.length === 0) {
+    console.log("(no data)");
+    return;
+  }
+  const firstRow = rows[0];
+  if (!firstRow) return;
+  const keys = Object.keys(firstRow);
+  const widths = {};
+  for (const key of keys) {
+    widths[key] = key.length;
+    for (const row of rows) {
+      const value = formatValue(row[key]);
+      widths[key] = Math.max(widths[key] ?? 0, value.length);
+    }
+  }
+  const header = keys.map((k) => k.padEnd(widths[k] ?? 0)).join("  ");
+  console.log(header);
+  console.log(keys.map((k) => "-".repeat(widths[k] ?? 0)).join("  "));
+  for (const row of rows) {
+    const line = keys.map((k) => formatValue(row[k]).padEnd(widths[k] ?? 0)).join("  ");
+    console.log(line);
+  }
+}
+function printKeyValue(obj) {
+  const maxKeyLen = Math.max(...Object.keys(obj).map((k) => k.length));
+  for (const [key, value] of Object.entries(obj)) {
+    console.log(`${key.padEnd(maxKeyLen)}  ${formatValue(value)}`);
+  }
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    if (Array.isArray(value)) {
+      return `[${value.length} items]`;
+    }
+    return "[object]";
+  }
+  return String(value);
+}
+function printTsv(data) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return;
+  }
+  const firstRow = data[0];
+  const keys = Object.keys(firstRow);
+  writeLine(keys.join("	"));
+  for (const row of data) {
+    writeLine(keys.map((k) => formatTsvValue(row[k])).join("	"));
+  }
+}
+function formatTsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value).replace(/\t/g, " ").replace(/\n/g, " ");
+}
+function outputSpeakerAnalytics(analytics, format) {
+  if (format === "plain") {
+    const mins = Math.round(analytics.totalDuration / 60);
+    writeLine(
+      `Meeting: ${mins} min, ${analytics.speakers.length} speakers, balance: ${analytics.balance}`
+    );
+    writeLine(`Dominant: ${analytics.dominantSpeaker} (${analytics.dominantSpeakerPercentage}%)`);
+    writeLine("");
+    for (const s of analytics.speakers) {
+      writeLine(
+        `${s.name}: ${Math.round(s.talkTime)}s (${s.talkTimePercentage}%) | ${s.wordCount} words | ${s.wordsPerMinute} wpm | ${s.turnCount} turns`
+      );
+    }
+    return;
+  }
+  if (format === "table" || format === "tsv") {
+    const rows = analytics.speakers.map((s) => ({
+      name: s.name,
+      talkTime: Math.round(s.talkTime),
+      "talkTime%": s.talkTimePercentage,
+      words: s.wordCount,
+      wpm: s.wordsPerMinute,
+      sentences: s.sentenceCount,
+      turns: s.turnCount
+    }));
+    output(rows, format);
+    return;
+  }
+  output(analytics, format);
+}
+function outputActionItems(result, format) {
+  if (format === "plain") {
+    const assignedCount = result.assignedItems;
+    writeLine(`Action Items (${result.totalItems} total, ${assignedCount} assigned):`);
+    writeLine("");
+    for (const item of result.items) {
+      writeLine(`${item.lineNumber}. ${item.text}`);
+      const parts = [];
+      if (item.assignee) {
+        parts.push(`Assignee: ${item.assignee}`);
+      }
+      if (item.dueDate) {
+        parts.push(`Due: ${item.dueDate}`);
+      }
+      if (parts.length > 0) {
+        writeLine(`   ${parts.join(" | ")}`);
+      }
+      writeLine("");
+    }
+    return;
+  }
+  if (format === "table" || format === "tsv") {
+    const rows = result.items.map((item) => ({
+      "#": item.lineNumber,
+      text: item.text,
+      assignee: item.assignee ?? "-",
+      dueDate: item.dueDate ?? "-"
+    }));
+    output(rows, format);
+    return;
+  }
+  output(result, format);
+}
+
+// src/cli/commands/ai-apps.ts
+function registerAiAppsCommand(program2) {
+  const cmd = program2.command("ai-apps").description("AI Apps output");
+  cmd.command("list").description("List AI App outputs").requiredOption("--transcript <id>", "Transcript ID (required)").option("--app <id>", "Filter by app ID").option("--limit <n>", "Max results (default: 10)", "10").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const apps = await client.aiApps.list({
+        transcript_id: opts.transcript,
+        app_id: opts.app,
+        limit: Number.parseInt(opts.limit, 10)
+      });
+      const formatted = apps.map((a) => ({
+        app_id: a.app_id,
+        title: a.title,
+        transcript_id: a.transcript_id,
+        created_at: a.created_at,
+        response: a.response?.substring(0, 100) + (a.response && a.response.length > 100 ? "..." : "")
+      }));
+      output(formatted, format);
+    })
+  );
+}
+
+// src/cli/utils/parse.ts
+function formatDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    return "0s";
+  }
+  const totalSeconds = Math.round(seconds);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const secs = totalSeconds % 60;
+  if (hours > 0) {
+    if (minutes > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${hours}h`;
+  }
+  if (minutes > 0) {
+    if (secs > 0) {
+      return `${minutes}m ${secs}s`;
+    }
+    return `${minutes}m`;
+  }
+  return `${secs}s`;
+}
+function parseTime(value) {
+  if (value.includes(":")) {
+    const parts = value.split(":");
+    if (parts.length === 2) {
+      const [mins, secs] = parts;
+      return Number.parseInt(mins ?? "0", 10) * 60 + Number.parseFloat(secs ?? "0");
+    }
+    if (parts.length === 3) {
+      const [hours, mins, secs] = parts;
+      return Number.parseInt(hours ?? "0", 10) * 3600 + Number.parseInt(mins ?? "0", 10) * 60 + Number.parseFloat(secs ?? "0");
+    }
+  }
+  return Number.parseFloat(value);
+}
+function parseAttendee(value) {
+  if (value.includes(":")) {
+    const colonIndex = value.indexOf(":");
+    const displayName = value.slice(0, colonIndex);
+    const email = value.slice(colonIndex + 1);
+    return { displayName, email };
+  }
+  return { email: value };
+}
+var VALID_PRIVACIES = ["public", "team", "participants"];
+function validatePrivacy(value) {
+  if (VALID_PRIVACIES.includes(value)) {
+    return value;
+  }
+  return null;
+}
+
+// src/cli/commands/audio.ts
+function collectAttendees(value, previous) {
+  return previous.concat([parseAttendee(value)]);
+}
+function registerAudioCommand(program2) {
+  const cmd = program2.command("audio").description("Audio/video upload for transcription");
+  cmd.command("upload <url>").description("Upload audio/video file for transcription").option("--title <title>", "Title for the transcript (max 256 chars)").option("--webhook <url>", "Webhook URL for completion notification").option("--language <code>", "Language code (e.g., en, de, fr)").option("--save-video", "Save video if applicable").option(
+    "--attendee <name:email>",
+    'Meeting attendee (repeatable, format: "Name:email@example.com" or just "email@example.com")',
+    collectAttendees,
+    []
+  ).option("--reference-id <id>", "Custom reference ID for tracking (max 128 chars)").option("--bypass-size-check", "Allow files smaller than 50kb").action(
+    withErrorHandling(async (url, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const result = await client.audio.upload({
+        url,
+        title: opts.title,
+        webhook: opts.webhook,
+        custom_language: opts.language,
+        save_video: opts.saveVideo,
+        attendees: opts.attendee.length > 0 ? opts.attendee : void 0,
+        client_reference_id: opts.referenceId,
+        bypass_size_check: opts.bypassSizeCheck
+      });
+      output(result, format);
+    })
+  );
+}
+
+// src/cli/commands/bites.ts
+function collectPrivacies(value, previous) {
+  const validated = validatePrivacy(value);
+  if (!validated) {
+    console.error(`Invalid privacy value: ${value}. Must be one of: public, team, participants`);
+    process.exit(1);
+  }
+  return previous.concat([validated]);
+}
+function registerBitesCommand(program2) {
+  const cmd = program2.command("bites").description("Soundbites/clips");
+  cmd.command("list").description("List bites").option("--transcript <id>", "Filter by transcript ID").option("--limit <n>", "Max results (default: 20)", "20").option("--mine", "Only my bites").option("--team", "All team bites").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const bites = await client.bites.list({
+        transcript_id: opts.transcript,
+        limit: Number.parseInt(opts.limit, 10),
+        mine: opts.mine,
+        my_team: opts.team
+      });
+      const formatted = bites.map((b) => ({
+        id: b.id,
+        name: b.name,
+        transcript_id: b.transcript_id,
+        status: b.status,
+        start_time: b.start_time,
+        end_time: b.end_time,
+        created_at: b.created_at
+      }));
+      output(formatted, format);
+    })
+  );
+  cmd.command("get <id>").description("Get bite details").action(
+    withErrorHandling(async (id) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const bite = await client.bites.get(id);
+      output(bite, format);
+    })
+  );
+  cmd.command("create").description("Create a bite/soundbite from a transcript").requiredOption("--transcript <id>", "Transcript ID (required)").requiredOption("--start <time>", "Start time in seconds or MM:SS format (required)").requiredOption("--end <time>", "End time in seconds or MM:SS format (required)").option("--name <name>", "Bite name (max 256 chars)").option("--media-type <type>", "Media type: video or audio").option("--summary <text>", "Summary (max 500 chars)").option(
+    "--privacy <level>",
+    "Privacy: public, team, or participants (repeatable)",
+    collectPrivacies,
+    []
+  ).action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const startTime = parseTime(opts.start);
+      const endTime = parseTime(opts.end);
+      if (endTime <= startTime) {
+        console.error("Error: End time must be greater than start time");
+        process.exit(1);
+      }
+      const result = await client.bites.create({
+        transcript_id: opts.transcript,
+        start_time: startTime,
+        end_time: endTime,
+        name: opts.name,
+        media_type: opts.mediaType,
+        summary: opts.summary,
+        privacies: opts.privacy.length > 0 ? opts.privacy : void 0
+      });
+      output(result, format);
+    })
+  );
+}
+
+// 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:** ${formatDuration2(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 formatDuration2(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: writeFile2 } = await import('fs/promises');
+    await writeFile2(outputPath, content, "utf-8");
+  }
+}
+
+// src/cli/commands/export.ts
+function registerExportCommand(program2) {
+  program2.command("export <transcript-id> [output-file]").description("Export transcript to markdown").option("--no-summary", "Exclude summary section").option("--no-timestamps", "Exclude timestamps").option("--format <format>", "Output format: markdown, json", "markdown").action(
+    withErrorHandling(async (transcriptId, outputFile, opts) => {
+      const client = getClient(program2);
+      const cliFormat = getOutputFormat(program2);
+      const transcript = await client.transcripts.get(transcriptId);
+      if (opts.format === "json") {
+        if (outputFile) {
+          await writeFile(outputFile, JSON.stringify(transcript, null, 2), "utf-8");
+          console.log(`Exported to ${outputFile}`);
+        } else {
+          output(transcript, cliFormat);
+        }
+        return;
+      }
+      const markdown = await transcriptToMarkdown(transcript, {
+        includeSummary: opts.summary,
+        includeTimestamps: opts.timestamps
+      });
+      if (outputFile) {
+        await writeFile(outputFile, markdown, "utf-8");
+        console.log(`Exported to ${outputFile}`);
+      } else {
+        console.log(markdown);
+      }
+    })
+  );
+}
+
+// src/cli/utils/date.ts
+function daysAgo(days) {
+  const date = /* @__PURE__ */ new Date();
+  date.setDate(date.getDate() - days);
+  date.setHours(0, 0, 0, 0);
+  return date.toISOString();
+}
+function startOfToday() {
+  const date = /* @__PURE__ */ new Date();
+  date.setHours(0, 0, 0, 0);
+  return date.toISOString();
+}
+function resolveDateRange(opts) {
+  if (opts.today) {
+    return { fromDate: startOfToday() };
+  }
+  if (opts.yesterday) {
+    return { fromDate: daysAgo(1), toDate: startOfToday() };
+  }
+  if (opts.lastWeek) {
+    return { fromDate: daysAgo(7) };
+  }
+  if (opts.lastMonth) {
+    return { fromDate: daysAgo(30) };
+  }
+  if (opts.days) {
+    const numDays = Number.parseInt(opts.days, 10);
+    if (!Number.isNaN(numDays) && numDays > 0) {
+      return { fromDate: daysAgo(numDays) };
+    }
+  }
+  return { fromDate: opts.from, toDate: opts.to };
+}
+
+// src/cli/commands/insights.ts
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+function registerInsightsCommand(program2) {
+  program2.command("insights").description("Get aggregate meeting insights").option("--from <date>", "From date (YYYY-MM-DD or ISO 8601)").option("--to <date>", "To date (YYYY-MM-DD or ISO 8601)").option("--today", "Meetings from today").option("--yesterday", "Meetings from yesterday").option("--last-week", "Meetings from last 7 days").option("--last-month", "Meetings from last 30 days").option("--days <n>", "Meetings from last N days").option("--mine", "Only my transcripts").option("--organizer <email>", "Filter by organizer email (repeatable)", collect, []).option("--participant <email>", "Filter by participant email (repeatable)", collect, []).option("--user-id <id>", "Filter by user ID").option("--channel <id>", "Filter by channel ID").option("--limit <n>", "Max transcripts to analyze").option("--external", "Only meetings with external (non-company) participants").option("--speaker <name>", "Only stats for specific speaker(s) (repeatable)", collect, []).option("--group-by <period>", "Group by: day, week, month").option("--top <n>", "Top N speakers/participants (default: 10)").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const { fromDate, toDate } = resolveDateRange(opts);
+      const insights = await client.transcripts.insights(
+        buildInsightsParams(opts, fromDate, toDate)
+      );
+      outputInsights(insights, format);
+    })
+  );
+}
+function buildInsightsParams(opts, fromDate, toDate) {
+  const topCount = opts.top ? Number.parseInt(opts.top, 10) : void 0;
+  return {
+    fromDate,
+    toDate,
+    mine: opts.mine,
+    organizers: opts.organizer.length > 0 ? opts.organizer : void 0,
+    participants: opts.participant.length > 0 ? opts.participant : void 0,
+    user_id: opts.userId,
+    channel_id: opts.channel,
+    limit: opts.limit ? Number.parseInt(opts.limit, 10) : void 0,
+    external: opts.external,
+    speakers: opts.speaker.length > 0 ? opts.speaker : void 0,
+    groupBy: opts.groupBy,
+    topSpeakersCount: topCount,
+    topParticipantsCount: topCount
+  };
+}
+function outputInsights(insights, format) {
+  if (format === "plain") {
+    outputInsightsPlain(insights);
+    return;
+  }
+  if (format === "table") {
+    outputInsightsTable(insights);
+    return;
+  }
+  output(insights, format);
+}
+function outputInsightsPlain(insights) {
+  outputHeader(insights);
+  outputSummaryStats(insights);
+  outputDayOfWeekStats(insights.byDayOfWeek);
+  outputTimeGroupStats(insights.byTimeGroup);
+  outputParticipantStats(insights);
+  outputSpeakerStats(insights);
+}
+function outputHeader(insights) {
+  const dateRange = formatDateRangeHeader(insights.earliestMeeting, insights.latestMeeting);
+  writeLine(`Meeting Insights (${dateRange})`);
+  writeLine("=".repeat(50));
+  writeLine("");
+}
+function outputSummaryStats(insights) {
+  writeLine(`Total meetings: ${insights.totalMeetings}`);
+  writeLine(`Total duration: ${formatDuration(insights.totalDurationMinutes * 60)}`);
+  writeLine(`Average duration: ${Math.round(insights.averageDurationMinutes)} min`);
+  writeLine("");
+}
+function outputDayOfWeekStats(byDayOfWeek) {
+  writeLine("Meetings by Day:");
+  const sortedDays = getSortedDays(byDayOfWeek);
+  for (const { day, stats } of sortedDays) {
+    if (stats.count > 0) {
+      const duration = formatDuration(stats.totalMinutes * 60);
+      writeLine(`  ${capitalize(day)}: ${stats.count} meetings (${duration})`);
+    }
+  }
+  writeLine("");
+}
+function outputTimeGroupStats(byTimeGroup) {
+  if (!byTimeGroup || byTimeGroup.length === 0) return;
+  writeLine("By Period:");
+  for (const group of byTimeGroup) {
+    const duration = formatDuration(group.totalMinutes * 60);
+    const avg = Math.round(group.averageMinutes);
+    writeLine(`  ${group.period}: ${group.count} meetings (${duration}, avg ${avg} min)`);
+  }
+  writeLine("");
+}
+function outputParticipantStats(insights) {
+  const avgPart = insights.averageParticipantsPerMeeting.toFixed(1);
+  writeLine(
+    `Participants: ${insights.totalUniqueParticipants} unique (avg ${avgPart} per meeting)`
+  );
+  if (insights.topParticipants.length > 0) {
+    writeLine("Top Participants:");
+    outputTopParticipants(insights.topParticipants.slice(0, 5));
+  }
+  writeLine("");
+}
+function outputTopParticipants(participants) {
+  for (let i = 0; i < participants.length; i++) {
+    const p = participants[i];
+    if (p) {
+      writeLine(`  ${i + 1}. ${p.email} (${p.meetingCount} meetings)`);
+    }
+  }
+}
+function outputSpeakerStats(insights) {
+  writeLine(`Speakers: ${insights.totalUniqueSpeakers} unique`);
+  if (insights.topSpeakers.length > 0) {
+    writeLine("Top Speakers:");
+    outputTopSpeakers(insights.topSpeakers.slice(0, 5));
+  }
+}
+function outputTopSpeakers(speakers) {
+  for (let i = 0; i < speakers.length; i++) {
+    const s = speakers[i];
+    if (s) {
+      const talkTime = formatDuration(s.totalTalkTimeSeconds);
+      writeLine(`  ${i + 1}. ${s.name} (${s.meetingCount} meetings, ${talkTime} talk time)`);
+    }
+  }
+}
+function outputInsightsTable(insights) {
+  const summary = {
+    totalMeetings: insights.totalMeetings,
+    totalDuration: formatDuration(insights.totalDurationMinutes * 60),
+    avgDuration: `${Math.round(insights.averageDurationMinutes)} min`,
+    dateRange: `${insights.earliestMeeting} to ${insights.latestMeeting}`,
+    uniqueParticipants: insights.totalUniqueParticipants,
+    avgParticipants: insights.averageParticipantsPerMeeting.toFixed(1),
+    uniqueSpeakers: insights.totalUniqueSpeakers
+  };
+  output(summary, "table");
+}
+function formatDateRangeHeader(earliest, latest) {
+  if (!earliest && !latest) return "All time";
+  if (earliest === latest) return formatReadableDate(earliest);
+  return `${formatReadableDate(earliest)} - ${formatReadableDate(latest)}`;
+}
+function formatReadableDate(dateStr) {
+  if (!dateStr) return "Unknown";
+  const date = new Date(dateStr);
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+}
+function getSortedDays(byDayOfWeek) {
+  const dayOrder = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday"
+  ];
+  return dayOrder.map((day) => ({ day, stats: byDayOfWeek[day] })).sort((a, b) => b.stats.count - a.stats.count);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/cli/commands/meetings.ts
+function registerMeetingsCommand(program2) {
+  const cmd = program2.command("meetings").description("Active meetings and bot control");
+  cmd.command("list").description("List active meetings").option("--state <state>", "Filter by state: active, paused").option("--email <email>", "Filter by user email (admin only)").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const states = opts.state ? [opts.state] : void 0;
+      const meetings = await client.meetings.active({
+        states,
+        email: opts.email
+      });
+      const formatted = meetings.map((m) => ({
+        id: m.id,
+        title: m.title,
+        organizer: m.organizer_email,
+        state: m.state,
+        start_time: m.start_time
+      }));
+      output(formatted, format);
+    })
+  );
+  cmd.command("add-bot <url>").description("Add Fireflies bot to a meeting").option("--title <title>", "Meeting title").option("--duration <min>", "Max duration in minutes (15-120)", "60").option("--password <password>", "Meeting password").option("--language <lang>", "Language code").action(
+    withErrorHandling(async (url, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const result = await client.meetings.addBot({
+        meeting_link: url,
+        title: opts.title,
+        duration: Number.parseInt(opts.duration, 10),
+        password: opts.password,
+        language: opts.language
+      });
+      output(result, format);
+    })
+  );
+}
+
+// src/cli/commands/realtime.ts
+function registerRealtimeCommand(program2) {
+  program2.command("realtime <meeting-id>").description("Stream live transcription to stdout").action(
+    withErrorHandling(async (meetingId) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      let closing = false;
+      const shutdown = () => {
+        if (!closing) {
+          closing = true;
+          process.exit(0);
+        }
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+      for await (const chunk of client.realtime.stream(meetingId)) {
+        if (closing) break;
+        if (format === "plain" || format === "table") {
+          writeLine(`[${chunk.speaker_name}]: ${chunk.text}`);
+        } else {
+          outputLine(chunk);
+        }
+      }
+    })
+  );
+}
+
+// src/cli/commands/search.ts
+function collect2(value, previous) {
+  return previous.concat([value]);
+}
+function formatTime(seconds) {
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function buildFlags(match) {
+  const flags = [];
+  if (match.sentence.isQuestion) flags.push("Q");
+  if (match.sentence.isTask) flags.push("T");
+  return flags.length > 0 ? ` [${flags.join(",")}]` : "";
+}
+function outputMatchPlain(match) {
+  for (const ctx of match.context.before) {
+    writeLine(`  [${ctx.speakerName}] ${ctx.text}`);
+  }
+  const time = formatTime(match.sentence.startTime);
+  const flagStr = buildFlags(match);
+  writeLine(`> [${time}] [${match.sentence.speakerName}]${flagStr} ${match.sentence.text}`);
+  for (const ctx of match.context.after) {
+    writeLine(`  [${ctx.speakerName}] ${ctx.text}`);
+  }
+  writeLine("");
+}
+function outputPlain(results) {
+  writeLine(
+    `Found ${results.totalMatches} matches in ${results.transcriptsWithMatches}/${results.transcriptsSearched} transcripts`
+  );
+  writeLine("");
+  let currentTranscript = "";
+  for (const match of results.matches) {
+    if (match.transcriptId !== currentTranscript) {
+      currentTranscript = match.transcriptId;
+      writeLine(`--- ${match.transcriptTitle} (${match.transcriptDate.split("T")[0]}) ---`);
+      writeLine(`    ${match.transcriptUrl}`);
+      writeLine("");
+    }
+    outputMatchPlain(match);
+  }
+}
+function outputTabular(results, format) {
+  const rows = results.matches.map((match) => ({
+    transcript: match.transcriptTitle.slice(0, 40),
+    date: match.transcriptDate.split("T")[0],
+    time: formatTime(match.sentence.startTime),
+    speaker: match.sentence.speakerName,
+    text: match.sentence.text.slice(0, 80),
+    isQuestion: match.sentence.isQuestion ? "Y" : "",
+    isTask: match.sentence.isTask ? "Y" : ""
+  }));
+  output(rows, format);
+}
+function outputSearchResults(results, format) {
+  if (format === "plain") {
+    outputPlain(results);
+    return;
+  }
+  if (format === "table" || format === "tsv") {
+    outputTabular(results, format);
+    return;
+  }
+  output(results, format);
+}
+function registerSearchCommand(program2) {
+  program2.command("search <query>").description("Search across transcripts for matching sentences").option("--speaker <name>", "Filter results by speaker name (repeatable)", collect2, []).option("--questions", "Only show sentences marked as questions").option("--tasks", "Only show sentences marked as tasks/action items").option("--context <n>", "Number of context sentences (default: 1)", "1").option("--case-sensitive", "Match case when searching").option(
+    "--scope <scope>",
+    "Search scope: title, sentences, all (default: sentences)",
+    "sentences"
+  ).option("--from <date>", "From date (YYYY-MM-DD or ISO 8601)").option("--to <date>", "To date (YYYY-MM-DD or ISO 8601)").option("--today", "Search transcripts from today").option("--yesterday", "Search transcripts from yesterday").option("--last-week", "Search transcripts from last 7 days").option("--last-month", "Search transcripts from last 30 days").option("--days <n>", "Search transcripts from last N days").option("--mine", "Only my transcripts").option("--organizer <email>", "Filter by organizer email (repeatable)", collect2, []).option("--participant <email>", "Filter by participant email (repeatable)", collect2, []).option("--limit <n>", "Max transcripts to search").action(
+    withErrorHandling(async (query, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const { fromDate, toDate } = resolveDateRange(opts);
+      const results = await client.transcripts.search(query, {
+        caseSensitive: opts.caseSensitive,
+        scope: opts.scope,
+        speakers: opts.speaker.length > 0 ? opts.speaker : void 0,
+        filterQuestions: opts.questions,
+        filterTasks: opts.tasks,
+        contextLines: Number.parseInt(opts.context, 10),
+        fromDate,
+        toDate,
+        mine: opts.mine,
+        organizers: opts.organizer.length > 0 ? opts.organizer : void 0,
+        participants: opts.participant.length > 0 ? opts.participant : void 0,
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : void 0
+      });
+      outputSearchResults(results, format);
+    })
+  );
+}
+
+// src/helpers/normalize.ts
+var DEFAULT_OPTIONS3 = {
+  timeUnit: "seconds",
+  includeRawData: false,
+  includeAIFilters: true,
+  includeSummary: true,
+  resolveSpeakerName: (speaker) => speaker.name,
+  enrichParticipant: () => ({})
+};
+function normalizeTranscript2(transcript, options) {
+  const opts = { ...DEFAULT_OPTIONS3, ...options };
+  const speakers = normalizeSpeakers(transcript.speakers ?? [], transcript, opts);
+  const sentences = normalizeSentences(transcript.sentences ?? [], opts);
+  const participants = normalizeParticipants(transcript, opts);
+  const summary = opts.includeSummary ? normalizeSummary(transcript.summary) : void 0;
+  const attendees = normalizeAttendees(transcript.meeting_attendance ?? []);
+  const channels = normalizeChannels(transcript.channels ?? []);
+  const analytics = normalizeAnalytics(transcript.analytics);
+  return {
+    id: `fireflies:${transcript.id}`,
+    title: transcript.title,
+    date: new Date(transcript.date),
+    duration: transcript.duration * 60,
+    // minutes → seconds
+    url: transcript.transcript_url,
+    speakers,
+    sentences,
+    participants,
+    summary,
+    attendees,
+    channels,
+    analytics,
+    source: {
+      provider: "fireflies",
+      originalId: transcript.id,
+      rawData: opts.includeRawData ? transcript : void 0
+    }
+  };
+}
+function normalizeSpeakers(speakers, transcript, opts) {
+  return speakers.map((speaker) => ({
+    id: speaker.id,
+    name: opts.resolveSpeakerName(speaker, transcript)
+  }));
+}
+function normalizeSentences(sentences, opts) {
+  const timeMultiplier = opts.timeUnit === "milliseconds" ? 1e3 : 1;
+  return sentences.map((sentence) => {
+    const normalized = {
+      index: sentence.index,
+      speakerId: sentence.speaker_id,
+      speakerName: sentence.speaker_name,
+      text: sentence.text,
+      rawText: sentence.raw_text,
+      startTime: parseTime2(sentence.start_time) * timeMultiplier,
+      endTime: parseTime2(sentence.end_time) * timeMultiplier
+    };
+    if (opts.includeAIFilters && sentence.ai_filters) {
+      const sentiment = mapSentiment(sentence.ai_filters.sentiment);
+      if (sentiment) {
+        normalized.sentiment = sentiment;
+      }
+      if (sentence.ai_filters.question) {
+        normalized.isQuestion = true;
+      }
+      if (sentence.ai_filters.task) {
+        normalized.isActionItem = true;
+      }
+    }
+    return normalized;
+  });
+}
+function parseTime2(timeStr) {
+  const parsed = Number.parseFloat(timeStr);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function mapSentiment(sentiment) {
+  if (!sentiment) return void 0;
+  const lower = sentiment.toLowerCase();
+  if (lower === "positive") return "positive";
+  if (lower === "negative") return "negative";
+  if (lower === "neutral") return "neutral";
+  return void 0;
+}
+function normalizeParticipants(transcript, opts) {
+  const participants = transcript.participants ?? [];
+  const attendeeMap = /* @__PURE__ */ new Map();
+  for (const attendee of transcript.meeting_attendees ?? []) {
+    if (attendee.email && attendee.name) {
+      attendeeMap.set(attendee.email.toLowerCase(), attendee.name);
+    }
+  }
+  return participants.map((email) => {
+    const isOrganizer = email.toLowerCase() === transcript.organizer_email.toLowerCase();
+    const attendeeName = attendeeMap.get(email.toLowerCase());
+    const enrichment = opts.enrichParticipant(email, transcript);
+    return {
+      name: enrichment.name ?? attendeeName ?? "",
+      email,
+      role: enrichment.role ?? (isOrganizer ? "organizer" : "attendee")
+    };
+  });
+}
+function normalizeSummary(summary) {
+  if (!summary) return void 0;
+  const keyPoints = parseKeyPoints(summary.shorthand_bullet);
+  return {
+    overview: summary.overview,
+    keyPoints: keyPoints.length > 0 ? keyPoints : void 0,
+    actionItems: summary.action_items,
+    outline: summary.outline,
+    topics: summary.topics_discussed
+  };
+}
+function parseKeyPoints(shorthandBullet) {
+  if (!shorthandBullet) return [];
+  return shorthandBullet.split("\n").map((line) => line.replace(/^[-*•]\s*/, "").trim()).filter((line) => line.length > 0);
+}
+function normalizeAttendees(attendance) {
+  return attendance.map((a) => ({
+    name: a.name,
+    joinTime: a.join_time ? new Date(a.join_time) : void 0,
+    leaveTime: a.leave_time ? new Date(a.leave_time) : void 0
+  }));
+}
+function normalizeChannels(channels) {
+  return channels.map((ch) => ({
+    id: ch.id,
+    title: ch.title,
+    isPrivate: ch.is_private ?? false
+  }));
+}
+function normalizeAnalytics(analytics) {
+  if (!analytics?.sentiments) return void 0;
+  return {
+    sentiments: {
+      positive: analytics.sentiments.positive_pct ?? 0,
+      neutral: analytics.sentiments.neutral_pct ?? 0,
+      negative: analytics.sentiments.negative_pct ?? 0
+    }
+  };
+}
+
+// src/helpers/speaker-analytics.ts
+function analyzeSpeakers(transcript, options = {}) {
+  const {
+    mergeSpeakersByName = true,
+    roundPercentages = true,
+    unbalancedThreshold = 40,
+    dominatedThreshold = 60
+  } = options;
+  const sentences = transcript.sentences ?? [];
+  if (sentences.length === 0) {
+    return emptyAnalytics();
+  }
+  const speakerMap = /* @__PURE__ */ new Map();
+  let prevSpeakerKey = null;
+  for (const sentence of sentences) {
+    const groupKey = mergeSpeakersByName ? sentence.speaker_name : sentence.speaker_id;
+    const data = getOrCreateSpeakerData(speakerMap, groupKey, sentence);
+    data.sentences.push(sentence);
+    data.talkTime += parseDuration(sentence);
+    data.wordCount += countWords(sentence.text);
+    if (groupKey !== prevSpeakerKey) {
+      data.turnCount++;
+      prevSpeakerKey = groupKey;
+    }
+  }
+  const totalTalkTime = sumTalkTime(speakerMap);
+  const totalDuration = calculateDuration2(sentences);
+  const totalWords = sumWords(speakerMap);
+  const speakers = buildSpeakerStats(speakerMap, totalTalkTime, roundPercentages);
+  speakers.sort((a, b) => b.talkTime - a.talkTime);
+  const dominant = speakers[0];
+  return {
+    speakers,
+    totalDuration,
+    totalTalkTime,
+    totalSentences: sentences.length,
+    totalWords,
+    dominantSpeaker: dominant?.name ?? "",
+    dominantSpeakerPercentage: dominant?.talkTimePercentage ?? 0,
+    balance: classifyBalance(speakers, unbalancedThreshold, dominatedThreshold)
+  };
+}
+function emptyAnalytics() {
+  return {
+    speakers: [],
+    totalDuration: 0,
+    totalTalkTime: 0,
+    totalSentences: 0,
+    totalWords: 0,
+    dominantSpeaker: "",
+    dominantSpeakerPercentage: 0,
+    balance: "balanced"
+  };
+}
+function getOrCreateSpeakerData(speakerMap, groupKey, sentence) {
+  let data = speakerMap.get(groupKey);
+  if (!data) {
+    data = {
+      id: sentence.speaker_id,
+      // Use first encountered ID
+      name: sentence.speaker_name,
+      sentences: [],
+      talkTime: 0,
+      wordCount: 0,
+      turnCount: 0
+    };
+    speakerMap.set(groupKey, data);
+  }
+  return data;
+}
+function parseDuration(sentence) {
+  const start = Number.parseFloat(sentence.start_time);
+  const end = Number.parseFloat(sentence.end_time);
+  return Math.max(0, end - start);
+}
+function countWords(text) {
+  if (!text || text.length === 0) return 0;
+  return text.trim().split(/\s+/).filter((w) => w.length > 0).length;
+}
+function sumTalkTime(speakerMap) {
+  let total = 0;
+  for (const data of speakerMap.values()) {
+    total += data.talkTime;
+  }
+  return total;
+}
+function sumWords(speakerMap) {
+  let total = 0;
+  for (const data of speakerMap.values()) {
+    total += data.wordCount;
+  }
+  return total;
+}
+function calculateDuration2(sentences) {
+  if (sentences.length === 0) return 0;
+  const lastSentence = sentences[sentences.length - 1];
+  return Number.parseFloat(lastSentence?.end_time ?? "0");
+}
+function buildSpeakerStats(speakerMap, totalTalkTime, roundPercentages) {
+  const speakers = [];
+  for (const data of speakerMap.values()) {
+    const percentage = totalTalkTime > 0 ? data.talkTime / totalTalkTime * 100 : 0;
+    const sentenceCount = data.sentences.length;
+    const talkTimeMinutes = data.talkTime / 60;
+    const wordsPerMinute = talkTimeMinutes > 0 ? data.wordCount / talkTimeMinutes : 0;
+    const averageSentenceLength = sentenceCount > 0 ? data.wordCount / sentenceCount : 0;
+    speakers.push({
+      name: data.name,
+      id: data.id,
+      talkTime: data.talkTime,
+      talkTimePercentage: roundPercentages ? Math.round(percentage) : percentage,
+      sentenceCount,
+      wordCount: data.wordCount,
+      wordsPerMinute: roundPercentages ? Math.round(wordsPerMinute) : wordsPerMinute,
+      averageSentenceLength,
+      turnCount: data.turnCount
+    });
+  }
+  return speakers;
+}
+function classifyBalance(speakers, unbalancedThreshold, dominatedThreshold) {
+  if (speakers.length <= 2) return "balanced";
+  const top = speakers[0]?.talkTimePercentage ?? 0;
+  if (top > dominatedThreshold) return "dominated";
+  if (top > unbalancedThreshold) return "unbalanced";
+  return "balanced";
+}
+
+// src/cli/commands/transcripts.ts
+function collect3(value, previous) {
+  return previous.concat([value]);
+}
+function buildActionItemFilterOptions(opts) {
+  const filterOptions = {};
+  if (opts.assignee?.length) {
+    filterOptions.assignees = opts.assignee;
+  }
+  if (opts.assignedOnly) {
+    filterOptions.assignedOnly = true;
+  }
+  if (opts.datedOnly) {
+    filterOptions.datedOnly = true;
+  }
+  return Object.keys(filterOptions).length > 0 ? filterOptions : void 0;
+}
+function buildMarkdownOptions(opts) {
+  return {
+    style: opts.style,
+    groupBy: opts.groupBy,
+    preset: opts.preset,
+    includeAssignee: opts.includeAssignee,
+    includeDueDate: opts.includeDueDate,
+    includeMeetingTitle: opts.includeMeeting,
+    includeSummary: opts.includeSummary
+  };
+}
+async function writeToFile(path, content, itemCount) {
+  const fs = await import('fs/promises');
+  await fs.writeFile(path, content);
+  console.log(`Wrote ${itemCount} action items to ${path}`);
+}
+function arrayOrUndefined(arr) {
+  return arr?.length ? arr : void 0;
+}
+function registerTranscriptsCommand(program2) {
+  const cmd = program2.command("transcripts").description("Manage transcripts");
+  cmd.command("list").description("List transcripts").option("--limit <n>", "Max results (default: 20)", "20").option("--from <date>", "From date (YYYY-MM-DD or ISO 8601)").option("--to <date>", "To date (YYYY-MM-DD or ISO 8601)").option("--today", "Transcripts from today").option("--yesterday", "Transcripts from yesterday").option("--last-week", "Transcripts from last 7 days").option("--last-month", "Transcripts from last 30 days").option("--days <n>", "Transcripts from last N days").option("--mine", "Only my transcripts").option("--keyword <text>", "Search keyword").option("--scope <scope>", "Search scope: title, sentences, all (default: all)").option("--organizer <email>", "Filter by organizer email (repeatable)", collect3, []).option("--participant <email>", "Filter by participant email (repeatable)", collect3, []).option("--participant-me", "Only meetings where I am a participant").option("--user-id <id>", "Filter by user ID").option("--channel <id>", "Filter by channel ID").option("--normalize", "Output in normalized provider-agnostic format").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const { fromDate, toDate } = resolveDateRange(opts);
+      const participants = [...opts.participant];
+      if (opts.participantMe) {
+        const me = await client.users.me();
+        participants.push(me.email);
+      }
+      const transcripts = await client.transcripts.list({
+        limit: Number.parseInt(opts.limit, 10),
+        fromDate,
+        toDate,
+        mine: opts.mine,
+        keyword: opts.keyword,
+        scope: opts.scope,
+        organizers: opts.organizer.length > 0 ? opts.organizer : void 0,
+        participants: participants.length > 0 ? participants : void 0,
+        user_id: opts.userId,
+        channel_id: opts.channel
+      });
+      if (opts.normalize) {
+        const fullTranscripts = await Promise.all(
+          transcripts.map((t) => client.transcripts.get(t.id))
+        );
+        const normalized = fullTranscripts.map((t) => normalizeTranscript2(t));
+        output(normalized, format);
+        return;
+      }
+      const useHumanDuration = format === "table" || format === "plain";
+      const formatted = transcripts.map((t) => ({
+        id: t.id,
+        title: t.title,
+        date: t.dateString,
+        duration: useHumanDuration ? formatDuration(t.duration * 60) : Math.round(t.duration),
+        organizer: t.organizer_email
+      }));
+      output(formatted, format);
+    })
+  );
+  cmd.command("get <id>").description("Get transcript details").option("--sentences", "Include sentences", true).option("--no-sentences", "Exclude sentences").option("--summary", "Include summary", true).option("--no-summary", "Exclude summary").option("--speakers", "Include speaker analytics").option("--no-merge", "Disable speaker merging (with --speakers)").option("--action-items", "Include extracted action items").action(
+    withErrorHandling(async (id, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const transcript = await client.transcripts.get(id, {
+        includeSentences: opts.sentences,
+        includeSummary: opts.summary || opts.actionItems
+      });
+      let result = { ...transcript };
+      if (opts.speakers) {
+        const analytics = analyzeSpeakers(transcript, {
+          mergeSpeakersByName: opts.merge !== false
+        });
+        result = { ...result, speakerAnalytics: analytics };
+      }
+      if (opts.actionItems) {
+        const actionItems = extractActionItems(transcript);
+        result = { ...result, actionItems };
+      }
+      output(result, format);
+    })
+  );
+  cmd.command("speakers <id>").description("Analyze speaker participation in a transcript").option("--no-merge", "Show separate entries for speakers with same name").option("--raw-percentages", "Show decimal percentages").action(
+    withErrorHandling(async (id, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const transcript = await client.transcripts.get(id);
+      const analytics = analyzeSpeakers(transcript, {
+        mergeSpeakersByName: opts.merge !== false,
+        roundPercentages: !opts.rawPercentages
+      });
+      outputSpeakerAnalytics(analytics, format);
+    })
+  );
+  const actionItemsCmd = cmd.command("action-items").description("Extract and export action items from transcripts");
+  actionItemsCmd.command("get <id>").description("Extract action items from a single transcript").option("--no-assignees", "Skip assignee detection").option("--no-due-dates", "Skip due date detection").option("--include-source", "Include source sentences from transcript").action(
+    withErrorHandling(async (id, opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const transcript = await client.transcripts.get(id, {
+        includeSummary: true,
+        includeSentences: opts.includeSource
+      });
+      const result = extractActionItems(transcript, {
+        detectAssignees: opts.assignees !== false,
+        detectDueDates: opts.dueDates !== false,
+        includeSourceSentences: opts.includeSource
+      });
+      outputActionItems(result, format);
+    })
+  );
+  actionItemsCmd.command("export").description("Export action items from multiple transcripts").option("--from <date>", "From date (YYYY-MM-DD or ISO 8601)").option("--to <date>", "To date (YYYY-MM-DD or ISO 8601)").option("--today", "Transcripts from today").option("--yesterday", "Transcripts from yesterday").option("--last-week", "Transcripts from last 7 days").option("--last-month", "Transcripts from last 30 days").option("--days <n>", "Transcripts from last N days").option("--mine", "Only my transcripts").option("--limit <n>", "Max transcripts to process").option("--organizer <email>", "Filter by organizer email (repeatable)", collect3, []).option("--participant <email>", "Filter by participant email (repeatable)", collect3, []).option("--assignee <name>", "Filter by assignee (repeatable)", collect3, []).option("--assigned-only", "Only items with assignees").option("--dated-only", "Only items with due dates").option("--style <style>", "List style: checkbox (default), bullet, numbered").option("--group-by <by>", "Group by: none (default), assignee, transcript, date").option("--preset <preset>", "Format preset: default, notion, obsidian, github").option("--include-assignee", "Show assignee inline").option("--include-due-date", "Show due date inline").option("--include-meeting", "Show meeting title inline").option("--include-summary", "Include stats summary").option("-o, --output <file>", "Write to file").action(
+    withErrorHandling(async (opts) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const { fromDate, toDate } = resolveDateRange(opts);
+      const filterOptions = buildActionItemFilterOptions(opts);
+      const result = await client.transcripts.exportActionItems({
+        fromDate,
+        toDate,
+        mine: opts.mine,
+        organizers: arrayOrUndefined(opts.organizer),
+        participants: arrayOrUndefined(opts.participant),
+        limit: opts.limit ? Number.parseInt(opts.limit, 10) : void 0,
+        filterOptions
+      });
+      if (format === "plain") {
+        const markdown = formatActionItemsMarkdown(result, buildMarkdownOptions(opts));
+        return opts.output ? writeToFile(opts.output, markdown, result.totalItems) : writeLine(markdown);
+      }
+      const content = format === "jsonl" ? result.items.map((i) => JSON.stringify(i)).join("\n") : JSON.stringify(result, null, 2);
+      return opts.output ? writeToFile(opts.output, content, result.totalItems) : output(result, format);
+    })
+  );
+  cmd.command("delete <id>").description("Delete a transcript").option("--confirm", "Skip confirmation (required for non-interactive)").action(
+    withErrorHandling(async (id, opts) => {
+      if (!opts.confirm) {
+        console.error("Error: --confirm flag required for delete operations");
+        process.exit(1);
+      }
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const result = await client.transcripts.delete(id);
+      output({ success: result, id }, format);
+    })
+  );
+}
+
+// src/cli/commands/users.ts
+function registerUsersCommand(program2) {
+  const cmd = program2.command("users").description("User management");
+  cmd.command("me").description("Show current user info").action(
+    withErrorHandling(async () => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const user = await client.users.me();
+      output(user, format);
+    })
+  );
+  cmd.command("list").description("List team users").action(
+    withErrorHandling(async () => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const users = await client.users.list();
+      const formatted = users.map((u) => ({
+        id: u.user_id,
+        name: u.name,
+        email: u.email,
+        role: u.role
+      }));
+      output(formatted, format);
+    })
+  );
+  cmd.command("get <id>").description("Get user details").action(
+    withErrorHandling(async (id) => {
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const user = await client.users.get(id);
+      output(user, format);
+    })
+  );
+  cmd.command("set-role <user-id>").description("Set user role (admin only)").requiredOption("--role <role>", "Role: admin or user (required)").action(
+    withErrorHandling(async (userId, opts) => {
+      const role = opts.role;
+      if (role !== "admin" && role !== "user") {
+        console.error('Error: Role must be "admin" or "user"');
+        process.exit(1);
+      }
+      const client = getClient(program2);
+      const format = getOutputFormat(program2);
+      const result = await client.users.setRole(userId, role);
+      output(result, format);
+    })
+  );
+}
+
+// src/cli/index.ts
+function getVersion() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const packagePath = join(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var program = new Command();
+program.name("fireflies").description("CLI for Fireflies.ai API").version(getVersion()).option("-k, --api-key <key>", "API key (or FIREFLIES_API_KEY env)").option("-o, --output <format>", "Output format: json, jsonl, table, tsv, plain", "json");
+registerTranscriptsCommand(program);
+registerSearchCommand(program);
+registerInsightsCommand(program);
+registerMeetingsCommand(program);
+registerUsersCommand(program);
+registerBitesCommand(program);
+registerAiAppsCommand(program);
+registerAudioCommand(program);
+registerRealtimeCommand(program);
+registerExportCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map