@indigoai-us/hq-cli 5.345.178 → 5.345.180

package/dist/lib/hot-channels/adapters/linear.js

@@ -0,0 +1,321 @@
+/**
+ * Linear hot channel (hot-signal-sync US-007).
+ *
+ * A poll adapter over the gateway's `list_issues` tool on the person's own
+ * Linear connection. It replaces the hq-pro Linear cron's watermark logic:
+ * list the issues assigned to the person whose `updatedAt` is after the
+ * watermark, ordered by `updatedAt`, and page through them with the gateway's
+ * cursor. The token stays in the gateway; this adapter never sees it.
+ *
+ * Budget: Linear allows 2,500 API requests per hour per personal token. One
+ * fetch is one request, and the loop stops after 20 pages per adapter per run,
+ * so a run spends at most 20 requests (2,000 issues at 100 per page). Comments
+ * are not fetched per issue; doing that is what blew the cron's budget.
+ *
+ * The cursor is a JSON object `{ watermark, after, high }`:
+ * - `watermark`: issues with `updatedAt` at or before it were already seen.
+ *   On a first run it is the catch-up `since`, and every pass starts from
+ *   `max(watermark, since)` so a long absence never pages through issues the
+ *   loop would drop as stale.
+ * - `after`: the gateway cursor of the next page while a pass is in progress.
+ * - `high`: the newest `updatedAt` seen so far in the pass.
+ * The watermark advances to `high` only when a pass completes (no next page).
+ * A run cut short by the page cap resumes the same pass on the next run with
+ * the old watermark, so an issue on a later page is never skipped. A cursor
+ * that does not parse falls back to `since`.
+ *
+ * Each landed document is a pointer in the hq-pro Linear source shape: the
+ * frontmatter carries the issue's identifier, state, priority, assignee,
+ * team, labels and url, the body is a short header with no description, and
+ * the `.raw.json` sidecar (named by `payload_ref`) holds the issue metadata.
+ * The event key is `linear:{issueId}:{updatedAt}`, so each update of an issue
+ * lands once.
+ *
+ * A revoked or expired token (`invalid_grant`) surfaces from the gateway call;
+ * run.ts turns it into a reconnect prompt in the run ledger and the cursor
+ * does not move.
+ */
+export const LINEAR_ADAPTER_ID = "linear";
+export const LINEAR_CHANNEL = "linear";
+export const LINEAR_PROVIDER = "linear";
+export const LINEAR_ISSUE_UPDATED_EVENT = "linear.issue.updated";
+export const LINEAR_LIST_ISSUES_TOOL = "list_issues";
+/** Linear's request budget for one personal token. */
+export const LINEAR_REQUESTS_PER_HOUR = 2500;
+export const LINEAR_CATCH_UP_WINDOW_MS = 14 * 24 * 60 * 60 * 1000;
+const SUGGESTION_WINDOW_MS = 14 * 24 * 60 * 60 * 1000;
+const DEFAULT_PAGE_SIZE = 100;
+const MAX_PAGE_SIZE = 250;
+export const LINEAR_ISSUE_FIELDS = [
+    "id",
+    "uuid",
+    "title",
+    "priority",
+    "url",
+    "createdAt",
+    "updatedAt",
+    "completedAt",
+    "dueDate",
+    "status",
+    "statusType",
+    "labels",
+    "assignee",
+    "project",
+    "team",
+];
+const PRIORITY_LABELS = {
+    0: "No priority",
+    1: "Urgent",
+    2: "High",
+    3: "Medium",
+    4: "Low",
+};
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIsoTime(value) {
+    return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+/** A name field may be a plain string or an object with a `name` (or `displayName`). */
+function nameOf(value) {
+    if (isRecord(value))
+        return nonEmptyString(value.name) ?? nonEmptyString(value.displayName);
+    return nonEmptyString(value);
+}
+function laterOf(a, b) {
+    return Date.parse(b) > Date.parse(a) ? b : a;
+}
+export function parseLinearCursor(cursor, since) {
+    const fresh = { watermark: since, after: null, high: null };
+    if (!cursor)
+        return fresh;
+    let parsed;
+    try {
+        parsed = JSON.parse(cursor);
+    }
+    catch {
+        return fresh;
+    }
+    if (!isRecord(parsed) || !isIsoTime(parsed.watermark))
+        return fresh;
+    const after = nonEmptyString(parsed.after) ?? null;
+    const high = isIsoTime(parsed.high) ? parsed.high : null;
+    // A new pass never starts before the catch-up window; a pass in progress
+    // keeps its watermark so its later pages filter the same way.
+    const watermark = after === null ? laterOf(parsed.watermark, since) : parsed.watermark;
+    return { watermark, after, high };
+}
+function serializeCursor(cursor) {
+    return JSON.stringify(cursor);
+}
+/** Unwrap a gateway result: a JSON string, an MCP `content[].text` block, or an object. */
+function unwrapResult(result) {
+    if (typeof result === "string") {
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return result;
+        }
+    }
+    if (isRecord(result) && Array.isArray(result.content)) {
+        const text = result.content
+            .map((block) => (isRecord(block) ? nonEmptyString(block.text) : undefined))
+            .find((value) => value !== undefined);
+        if (text !== undefined)
+            return unwrapResult(text);
+    }
+    return result;
+}
+function parseIssuePage(result) {
+    const body = unwrapResult(result);
+    if (Array.isArray(body))
+        return { issues: body, hasNextPage: false, nextCursor: null };
+    if (!isRecord(body))
+        throw new Error("Linear list_issues returned an unexpected response");
+    const issues = Array.isArray(body.issues) ? body.issues : Array.isArray(body.nodes) ? body.nodes : null;
+    if (issues === null)
+        throw new Error("Linear list_issues returned no issues list");
+    const pageInfo = isRecord(body.pageInfo) ? body.pageInfo : {};
+    const hasNextPage = body.hasNextPage === true || pageInfo.hasNextPage === true;
+    const nextCursor = nonEmptyString(body.cursor) ?? nonEmptyString(body.endCursor) ?? nonEmptyString(pageInfo.endCursor) ?? null;
+    return { issues, hasNextPage: hasNextPage && nextCursor !== null, nextCursor };
+}
+function labelsOf(value) {
+    const list = isRecord(value) && Array.isArray(value.nodes) ? value.nodes : value;
+    if (!Array.isArray(list))
+        return [];
+    return list.map((label) => nameOf(label)).filter((name) => name !== undefined);
+}
+/** Normalize one `list_issues` item. Returns undefined when it has no id or `updatedAt`. */
+export function toLinearIssue(item) {
+    if (!isRecord(item))
+        return undefined;
+    const updatedAt = isIsoTime(item.updatedAt) ? item.updatedAt : undefined;
+    const id = nonEmptyString(item.id);
+    const uuid = nonEmptyString(item.uuid) ?? id;
+    const identifier = nonEmptyString(item.identifier) ?? id ?? uuid;
+    if (!updatedAt || !uuid || !identifier)
+        return undefined;
+    const status = item.status ?? item.state;
+    const issue = {
+        uuid,
+        identifier,
+        title: nonEmptyString(item.title) ?? identifier,
+        updatedAt,
+        labels: labelsOf(item.labels),
+    };
+    const createdAt = nonEmptyString(item.createdAt);
+    const completedAt = nonEmptyString(item.completedAt);
+    const dueDate = nonEmptyString(item.dueDate);
+    const url = nonEmptyString(item.url);
+    const priority = isRecord(item.priority) ? item.priority.value : item.priority;
+    const state = nameOf(status);
+    const stateType = nonEmptyString(item.statusType) ?? (isRecord(status) ? nonEmptyString(status.type) : undefined);
+    const assignee = nameOf(item.assignee);
+    const team = nameOf(item.team);
+    const project = nameOf(item.project);
+    if (createdAt)
+        issue.createdAt = createdAt;
+    if (completedAt)
+        issue.completedAt = completedAt;
+    if (dueDate)
+        issue.dueDate = dueDate;
+    if (url)
+        issue.url = url;
+    if (typeof priority === "number" && Number.isInteger(priority))
+        issue.priority = priority;
+    if (state)
+        issue.state = state;
+    if (stateType)
+        issue.stateType = stateType;
+    if (assignee)
+        issue.assignee = assignee;
+    if (team)
+        issue.team = team;
+    if (project)
+        issue.project = project;
+    return issue;
+}
+function priorityLabel(priority) {
+    return PRIORITY_LABELS[priority] ?? `P${priority}`;
+}
+/** Frontmatter in the hq-pro Linear source shape, minus fields landing reserves. */
+function frontmatterFor(issue) {
+    const fm = {
+        issue_id: issue.uuid,
+        identifier: issue.identifier,
+        issue_updated_at: issue.updatedAt,
+    };
+    if (issue.state)
+        fm.state = issue.state;
+    if (issue.stateType)
+        fm.state_type = issue.stateType;
+    if (issue.priority !== undefined) {
+        fm.priority = priorityLabel(issue.priority);
+        fm.priority_number = String(issue.priority);
+    }
+    if (issue.assignee)
+        fm.assignee = issue.assignee;
+    if (issue.team)
+        fm.team = issue.team;
+    if (issue.project)
+        fm.project = issue.project;
+    if (issue.labels.length > 0)
+        fm.labels = issue.labels.join(", ");
+    if (issue.dueDate)
+        fm.due_date = issue.dueDate;
+    if (issue.createdAt)
+        fm.issue_created_at = issue.createdAt;
+    if (issue.completedAt)
+        fm.completed_at = issue.completedAt;
+    if (issue.url)
+        fm.url = issue.url;
+    return fm;
+}
+function bodyFor(issue) {
+    const lines = [`Linear issue ${issue.identifier} updated ${issue.updatedAt}.`];
+    if (issue.state)
+        lines.push(`State: ${issue.state}`);
+    if (issue.priority !== undefined)
+        lines.push(`Priority: ${priorityLabel(issue.priority)}`);
+    if (issue.team)
+        lines.push(`Team: ${issue.team}`);
+    if (issue.project)
+        lines.push(`Project: ${issue.project}`);
+    if (issue.url)
+        lines.push(`Link: ${issue.url}`);
+    return lines.join("\n");
+}
+function toEvent(issue, personUid) {
+    return {
+        providerId: issue.uuid,
+        version: issue.updatedAt,
+        who: personUid,
+        what: LINEAR_ISSUE_UPDATED_EVENT,
+        where: issue.project ? `${issue.team ?? "linear"}/${issue.project}` : (issue.team ?? "linear"),
+        when: issue.updatedAt,
+        audience: [personUid],
+        title: `${issue.identifier} ${issue.title}`,
+        body: bodyFor(issue),
+        raw: issue,
+        frontmatter: frontmatterFor(issue),
+    };
+}
+export function createLinearAdapter(options = {}) {
+    const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(options.pageSize ?? DEFAULT_PAGE_SIZE)));
+    async function fetch(cursor, ctx) {
+        if (!ctx.gateway)
+            throw new Error("Linear hot channel needs a gateway connection");
+        const state = parseLinearCursor(cursor, ctx.since);
+        const args = {
+            assignee: "me",
+            updatedAt: state.watermark,
+            orderBy: "updatedAt",
+            limit: pageSize,
+            fields: [...LINEAR_ISSUE_FIELDS],
+        };
+        if (state.after)
+            args.cursor = state.after;
+        const page = parseIssuePage(await ctx.gateway.call(LINEAR_LIST_ISSUES_TOOL, args));
+        const watermarkMs = Date.parse(state.watermark);
+        let high = state.high;
+        const events = [];
+        for (const item of page.issues) {
+            const issue = toLinearIssue(item);
+            // Strictly after the watermark: an issue updated exactly at it was seen.
+            if (!issue || Date.parse(issue.updatedAt) <= watermarkMs)
+                continue;
+            high = high === null ? issue.updatedAt : laterOf(high, issue.updatedAt);
+            events.push(toEvent(issue, ctx.personUid));
+        }
+        if (page.hasNextPage) {
+            return {
+                events,
+                cursor: serializeCursor({ watermark: state.watermark, after: page.nextCursor, high }),
+                hasMore: true,
+            };
+        }
+        return {
+            events,
+            cursor: serializeCursor({ watermark: high ?? state.watermark, after: null, high: null }),
+            hasMore: false,
+        };
+    }
+    return {
+        id: LINEAR_ADAPTER_ID,
+        channel: LINEAR_CHANNEL,
+        transport: "poll",
+        hotEventTypes: [LINEAR_ISSUE_UPDATED_EVENT],
+        catchUpWindow: { maxLookbackMs: LINEAR_CATCH_UP_WINDOW_MS },
+        tokenScope: { provider: LINEAR_PROVIDER, scopes: ["read"] },
+        // Declared as data only. US-014 evaluates it, together with issues
+        // assigned to the person and projects with recent updates.
+        suggestionRule: { kind: "recent-activity", withinMs: SUGGESTION_WINDOW_MS, minEvents: 1 },
+        fetch,
+    };
+}
+//# sourceMappingURL=linear.js.map

package/dist/lib/hot-channels/adapters/meeting-providers.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Meeting-notes providers for the meetings hot channel: Fireflies and Granola,
+ * read through the HQ integration gateway on the person's own connection.
+ *
+ * A person who has no HQ meeting bot yet (a new user) still records meetings
+ * in one of these tools. The meetings adapter lists their recent meetings
+ * here, reads each one's notes and transcript, and lands them like a bot
+ * transcript. Only read tools are called.
+ *
+ * Gateway tools (shapes taken from live indigo responses, 2026-10-29):
+ * - Fireflies `fireflies_get_transcripts` ({ fromDate, toDate, limit<=50, skip })
+ *   returns a TOON-style text list (`- id: …`, `dateString`, `participants[n]: a,b`);
+ *   `fireflies_get_transcript` and `fireflies_get_summary` ({ transcriptId })
+ *   return `Key: value` text with the sentences and the summary.
+ * - Granola `list_meetings` ({ time_range: "custom", from_date, to_date,
+ *   involvement, limit, cursor }) returns XML-ish text (`<meeting …>` elements,
+ *   `<pagination has_more next_cursor>`); `get_meetings` ({ meeting_ids })
+ *   returns notes, AI summary and attendees; `get_meeting_transcript`
+ *   ({ meeting_id }) returns the transcript on plans that include it.
+ */
+import type { HotChannelGateway } from "../contract.js";
+export declare const FIREFLIES_PROVIDER = "fireflies";
+export declare const GRANOLA_PROVIDER = "granola";
+export declare const MEETING_NOTE_PROVIDERS: readonly string[];
+export declare const FIREFLIES_LIST_TOOL = "fireflies_get_transcripts";
+export declare const FIREFLIES_TRANSCRIPT_TOOL = "fireflies_get_transcript";
+export declare const FIREFLIES_SUMMARY_TOOL = "fireflies_get_summary";
+export declare const GRANOLA_LIST_TOOL = "list_meetings";
+export declare const GRANOLA_GET_TOOL = "get_meetings";
+export declare const GRANOLA_TRANSCRIPT_TOOL = "get_meeting_transcript";
+/** One meeting as listed by a provider, before its content is read. */
+export interface ProviderMeeting {
+    provider: string;
+    id: string;
+    title: string;
+    /** Meeting start, epoch ms. */
+    startMs: number;
+    participants: string[];
+    organizer?: string;
+    meetingUrl?: string;
+    calendarEventId?: string;
+}
+/** The meeting's readable content, as returned by the provider. */
+export interface ProviderMeetingContent {
+    /** Text that goes in the transcript document, provider output verbatim. */
+    text: string;
+    /** False when the provider has neither a transcript nor notes for it yet. */
+    hasContent: boolean;
+}
+export interface MeetingProvider {
+    provider: string;
+    /** Meetings that started in [fromMs, toMs], oldest first. */
+    list(gateway: HotChannelGateway, fromMs: number, toMs: number): Promise<ProviderMeeting[]>;
+    read(gateway: HotChannelGateway, meeting: ProviderMeeting): Promise<ProviderMeetingContent>;
+}
+/** The text of a gateway result: a string, or the MCP `content[].text` blocks joined. */
+export declare function resultText(result: unknown): string;
+/** Parse the Fireflies `fireflies_get_transcripts` text list. */
+export declare function parseFirefliesList(text: string): ProviderMeeting[];
+export declare const firefliesProvider: MeetingProvider;
+/** Parse the Granola `list_meetings` text: `<meeting …>` elements and `<pagination …>`. */
+export declare function parseGranolaList(text: string): {
+    meetings: ProviderMeeting[];
+    nextCursor: string | null;
+};
+export declare const granolaProvider: MeetingProvider;
+export declare const MEETING_PROVIDERS: ReadonlyMap<string, MeetingProvider>;
+/** Lowercased title with punctuation and spacing collapsed. */
+export declare function normalizeTitle(title: string): string;
+/** The facts two recordings of one meeting share. */
+export interface MeetingIdentity {
+    startMs: number;
+    title: string;
+    participants: readonly string[];
+    meetingUrl?: string;
+    calendarEventId?: string;
+}
+/** Recordings that start this close together may be the same meeting. */
+export declare const SAME_MEETING_WINDOW_MS: number;
+/**
+ * Whether two recordings are the same meeting: the same calendar event, or
+ * starts within 30 minutes plus the same call link, a matching title, or at
+ * least two participants and more than half of the smaller list in common.
+ */
+export declare function sameMeeting(a: MeetingIdentity, b: MeetingIdentity): boolean;
+//# sourceMappingURL=meeting-providers.d.ts.map

package/dist/lib/hot-channels/adapters/meeting-providers.js

@@ -0,0 +1,253 @@
+/**
+ * Meeting-notes providers for the meetings hot channel: Fireflies and Granola,
+ * read through the HQ integration gateway on the person's own connection.
+ *
+ * A person who has no HQ meeting bot yet (a new user) still records meetings
+ * in one of these tools. The meetings adapter lists their recent meetings
+ * here, reads each one's notes and transcript, and lands them like a bot
+ * transcript. Only read tools are called.
+ *
+ * Gateway tools (shapes taken from live indigo responses, 2026-10-29):
+ * - Fireflies `fireflies_get_transcripts` ({ fromDate, toDate, limit<=50, skip })
+ *   returns a TOON-style text list (`- id: …`, `dateString`, `participants[n]: a,b`);
+ *   `fireflies_get_transcript` and `fireflies_get_summary` ({ transcriptId })
+ *   return `Key: value` text with the sentences and the summary.
+ * - Granola `list_meetings` ({ time_range: "custom", from_date, to_date,
+ *   involvement, limit, cursor }) returns XML-ish text (`<meeting …>` elements,
+ *   `<pagination has_more next_cursor>`); `get_meetings` ({ meeting_ids })
+ *   returns notes, AI summary and attendees; `get_meeting_transcript`
+ *   ({ meeting_id }) returns the transcript on plans that include it.
+ */
+export const FIREFLIES_PROVIDER = "fireflies";
+export const GRANOLA_PROVIDER = "granola";
+export const MEETING_NOTE_PROVIDERS = [FIREFLIES_PROVIDER, GRANOLA_PROVIDER];
+export const FIREFLIES_LIST_TOOL = "fireflies_get_transcripts";
+export const FIREFLIES_TRANSCRIPT_TOOL = "fireflies_get_transcript";
+export const FIREFLIES_SUMMARY_TOOL = "fireflies_get_summary";
+export const GRANOLA_LIST_TOOL = "list_meetings";
+export const GRANOLA_GET_TOOL = "get_meetings";
+export const GRANOLA_TRANSCRIPT_TOOL = "get_meeting_transcript";
+const FIREFLIES_PAGE = 50;
+const GRANOLA_PAGE = 100;
+/** List pages read per provider per fetch; bounds a backfill. */
+const MAX_LIST_PAGES = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The text of a gateway result: a string, or the MCP `content[].text` blocks joined. */
+export function resultText(result) {
+    if (typeof result === "string")
+        return result;
+    if (isRecord(result) && Array.isArray(result.content)) {
+        return result.content
+            .map((block) => (isRecord(block) && typeof block.text === "string" ? block.text : ""))
+            .filter((t) => t !== "")
+            .join("\n");
+    }
+    return result === undefined || result === null ? "" : JSON.stringify(result);
+}
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g;
+function emailsIn(text) {
+    return [...new Set((text.match(EMAIL) ?? []).map((e) => e.toLowerCase()))];
+}
+function unquote(value) {
+    const v = value.trim();
+    return v.length >= 2 && v.startsWith('"') && v.endsWith('"') ? v.slice(1, -1) : v;
+}
+function day(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/** Parse the Fireflies `fireflies_get_transcripts` text list. */
+export function parseFirefliesList(text) {
+    const out = [];
+    const chunks = text.split(/^\s*- id:/m).slice(1);
+    for (const chunk of chunks) {
+        const lines = chunk.split(/\r?\n/);
+        const id = unquote(lines[0] ?? "");
+        const field = (name) => {
+            const re = new RegExp(`^\\s*${name}:\\s*(.*)$`);
+            for (const line of lines) {
+                const m = re.exec(line);
+                if (m)
+                    return unquote(m[1]);
+            }
+            return undefined;
+        };
+        const title = field("title");
+        const when = field("dateString");
+        const startMs = when ? Date.parse(when) : NaN;
+        if (!id || !title || title === "null" || Number.isNaN(startMs))
+            continue;
+        const organizer = field("organizer_email");
+        const link = field("meeting_link");
+        out.push({
+            provider: FIREFLIES_PROVIDER,
+            id,
+            title,
+            startMs,
+            participants: emailsIn(lines.slice(1).filter((l) => !/meeting_link:/.test(l)).join("\n")),
+            ...(organizer && organizer !== "null" ? { organizer: organizer.toLowerCase() } : {}),
+            ...(link && link !== "null" ? { meetingUrl: link } : {}),
+        });
+    }
+    return out;
+}
+/** `Key: value` lines of a Fireflies detail response. */
+function firefliesField(text, name) {
+    const m = new RegExp(`^${name}:\\s*(.*)$`, "m").exec(text);
+    return m ? m[1].trim() : undefined;
+}
+export const firefliesProvider = {
+    provider: FIREFLIES_PROVIDER,
+    async list(gateway, fromMs, toMs) {
+        const seen = new Map();
+        for (let page = 0; page < MAX_LIST_PAGES; page += 1) {
+            const text = resultText(await gateway.call(FIREFLIES_LIST_TOOL, {
+                fromDate: day(fromMs),
+                toDate: day(toMs),
+                limit: FIREFLIES_PAGE,
+                skip: page * FIREFLIES_PAGE,
+            }));
+            const items = parseFirefliesList(text);
+            for (const item of items)
+                seen.set(item.id, item);
+            if (items.length < FIREFLIES_PAGE)
+                break;
+        }
+        return [...seen.values()].filter((m) => m.startMs >= fromMs && m.startMs <= toMs).sort(byStart);
+    },
+    async read(gateway, meeting) {
+        const transcript = resultText(await gateway.call(FIREFLIES_TRANSCRIPT_TOOL, { transcriptId: meeting.id }));
+        const summary = resultText(await gateway.call(FIREFLIES_SUMMARY_TOOL, { transcriptId: meeting.id }));
+        const calId = firefliesField(transcript, "Cal Id");
+        if (calId && !meeting.calendarEventId)
+            meeting.calendarEventId = calId;
+        const noSentences = /^Sentences:\s*No sentences\s*$/m.test(transcript) || transcript.trim() === "";
+        const noSummary = /^Summary:\s*No summary\s*$/m.test(summary) || summary.trim() === "";
+        return {
+            text: ["## Summary", "", summary.trim(), "", "## Transcript", "", transcript.trim(), ""].join("\n"),
+            hasContent: !(noSentences && noSummary),
+        };
+    },
+};
+function xmlAttrs(tag) {
+    const attrs = {};
+    for (const m of tag.matchAll(/([A-Za-z_][\w-]*)="([^"]*)"/g))
+        attrs[m[1]] = m[2];
+    return attrs;
+}
+/** Parse the Granola `list_meetings` text: `<meeting …>` elements and `<pagination …>`. */
+export function parseGranolaList(text) {
+    const meetings = [];
+    for (const chunk of text.split(/<meeting\s/).slice(1)) {
+        const close = chunk.search(/<\/meeting>/);
+        const body = close >= 0 ? chunk.slice(0, close) : chunk.split(/<pagination\b/)[0];
+        const tagEnd = body.indexOf(">");
+        const attrs = xmlAttrs(tagEnd >= 0 ? body.slice(0, tagEnd) : body);
+        const id = attrs.id ?? attrs.meeting_id ?? attrs.note_id;
+        const titleTag = /<title>([\s\S]*?)<\/title>/.exec(body);
+        const title = attrs.title ?? titleTag?.[1]?.trim();
+        const when = attrs.meeting_at ?? attrs.date ?? attrs.start ?? attrs.created_at;
+        const startMs = when ? Date.parse(when) : NaN;
+        if (!id || !title || Number.isNaN(startMs))
+            continue;
+        const participants = emailsIn(tagEnd >= 0 ? body.slice(tagEnd) : "");
+        meetings.push({ provider: GRANOLA_PROVIDER, id, title, startMs, participants });
+    }
+    const pagination = /<pagination\b([^>]*)>/.exec(text);
+    const p = pagination ? xmlAttrs(pagination[1]) : {};
+    const nextCursor = p.has_more === "true" && p.next_cursor ? p.next_cursor : null;
+    return { meetings, nextCursor };
+}
+export const granolaProvider = {
+    provider: GRANOLA_PROVIDER,
+    async list(gateway, fromMs, toMs) {
+        const seen = new Map();
+        let cursor = null;
+        for (let page = 0; page < MAX_LIST_PAGES; page += 1) {
+            const args = {
+                time_range: "custom",
+                from_date: new Date(fromMs).toISOString(),
+                to_date: new Date(toMs).toISOString(),
+                involvement: { captured_by_me: true, listed_as_participant: true },
+                limit: GRANOLA_PAGE,
+            };
+            if (cursor)
+                args.cursor = cursor;
+            const parsed = parseGranolaList(resultText(await gateway.call(GRANOLA_LIST_TOOL, args)));
+            for (const m of parsed.meetings)
+                seen.set(m.id, m);
+            cursor = parsed.nextCursor;
+            if (!cursor)
+                break;
+        }
+        return [...seen.values()].filter((m) => m.startMs >= fromMs && m.startMs <= toMs).sort(byStart);
+    },
+    async read(gateway, meeting) {
+        const notes = resultText(await gateway.call(GRANOLA_GET_TOOL, { meeting_ids: [meeting.id] }));
+        let transcript = "";
+        try {
+            transcript = resultText(await gateway.call(GRANOLA_TRANSCRIPT_TOOL, { meeting_id: meeting.id }));
+        }
+        catch (err) {
+            // Some Granola plans do not include transcripts; the notes still land.
+            if (err.code === "HOT_CHANNEL_RECONNECT_REQUIRED")
+                throw err;
+        }
+        const parts = ["## Notes", "", notes.trim(), ""];
+        if (transcript.trim() !== "")
+            parts.push("## Transcript", "", transcript.trim(), "");
+        return { text: parts.join("\n"), hasContent: notes.trim() !== "" || transcript.trim() !== "" };
+    },
+};
+function byStart(a, b) {
+    return a.startMs - b.startMs || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+export const MEETING_PROVIDERS = new Map([
+    [FIREFLIES_PROVIDER, firefliesProvider],
+    [GRANOLA_PROVIDER, granolaProvider],
+]);
+/** Lowercased title with punctuation and spacing collapsed. */
+export function normalizeTitle(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function urlKey(url) {
+    if (!url)
+        return undefined;
+    try {
+        const u = new URL(url);
+        return `${u.host}${u.pathname}`.toLowerCase().replace(/\/+$/, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Recordings that start this close together may be the same meeting. */
+export const SAME_MEETING_WINDOW_MS = 30 * 60 * 1000;
+/**
+ * Whether two recordings are the same meeting: the same calendar event, or
+ * starts within 30 minutes plus the same call link, a matching title, or at
+ * least two participants and more than half of the smaller list in common.
+ */
+export function sameMeeting(a, b) {
+    if (a.calendarEventId && b.calendarEventId && a.calendarEventId === b.calendarEventId)
+        return true;
+    if (Math.abs(a.startMs - b.startMs) > SAME_MEETING_WINDOW_MS)
+        return false;
+    const ua = urlKey(a.meetingUrl);
+    if (ua && ua === urlKey(b.meetingUrl))
+        return true;
+    const ta = normalizeTitle(a.title);
+    const tb = normalizeTitle(b.title);
+    if (ta !== "" && tb !== "" && (ta === tb || ta.includes(tb) || tb.includes(ta)))
+        return true;
+    const pa = new Set(a.participants.map((p) => p.toLowerCase()));
+    const pb = b.participants.map((p) => p.toLowerCase());
+    const smaller = Math.min(pa.size, pb.length);
+    const common = pb.filter((p) => pa.has(p)).length;
+    return common >= 2 && common * 2 > smaller;
+}
+//# sourceMappingURL=meeting-providers.js.map