@pinet/slack-bridge 0.1.0

package/dist/slack-block-kit.js

@@ -0,0 +1,242 @@
+import { decodeSlackModalPrivateMetadata } from "./slack-modals.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function asRecordArray(value) {
+    if (!Array.isArray(value) || value.some((item) => !isRecord(item))) {
+        throw new Error("Slack blocks must be a JSON array of objects.");
+    }
+    return value;
+}
+function tryParseJson(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeViewStateValue(value) {
+    const result = {};
+    if (typeof value.type === "string") {
+        result.type = value.type;
+    }
+    if (typeof value.value === "string") {
+        result.value = value.value;
+    }
+    if (typeof value.selected_date === "string") {
+        result.selectedDate = value.selected_date;
+    }
+    if (typeof value.selected_time === "string") {
+        result.selectedTime = value.selected_time;
+    }
+    if (typeof value.selected_conversation === "string") {
+        result.selectedConversation = value.selected_conversation;
+    }
+    if (typeof value.selected_channel === "string") {
+        result.selectedChannel = value.selected_channel;
+    }
+    if (typeof value.selected_user === "string") {
+        result.selectedUser = value.selected_user;
+    }
+    if (typeof value.selected_option === "object" && value.selected_option !== null) {
+        result.selectedOption = value.selected_option;
+    }
+    if (Array.isArray(value.selected_options)) {
+        result.selectedOptions = value.selected_options;
+    }
+    if (Array.isArray(value.selected_conversations)) {
+        result.selectedConversations = value.selected_conversations;
+    }
+    if (Array.isArray(value.selected_channels)) {
+        result.selectedChannels = value.selected_channels;
+    }
+    if (Array.isArray(value.selected_users)) {
+        result.selectedUsers = value.selected_users;
+    }
+    return result;
+}
+function getActionText(action) {
+    const text = asRecord(action.text);
+    return asString(text?.text);
+}
+function normalizeAction(action) {
+    const actionId = asString(action.action_id);
+    if (!actionId)
+        return null;
+    const value = asString(action.value);
+    return {
+        actionId,
+        blockId: asString(action.block_id),
+        text: getActionText(action),
+        type: asString(action.type),
+        style: asString(action.style),
+        value,
+        parsedValue: tryParseJson(value),
+        actionTs: asString(action.action_ts),
+    };
+}
+function sanitizeNormalizedActions(actions) {
+    return actions.map((action) => ({
+        actionId: action.actionId,
+        blockId: action.blockId ?? null,
+        text: action.text ?? null,
+        type: action.type ?? null,
+        style: action.style ?? null,
+        value: action.value ?? null,
+        parsedValue: action.parsedValue ?? null,
+        actionTs: action.actionTs ?? null,
+    }));
+}
+export function normalizeSlackBlocksInput(blocks) {
+    return asRecordArray(blocks).map((block) => ({ ...block }));
+}
+export function summarizeSlackBlocksForPolicy(blocks) {
+    if (!Array.isArray(blocks))
+        return "0";
+    return String(blocks.length);
+}
+export function encodeSlackBlockActionValue(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+export function extractSlackInteractivePayloadFromEnvelope(envelope) {
+    if (envelope.type !== "interactive")
+        return null;
+    const payloadValue = envelope.payload;
+    let payload = payloadValue;
+    if (typeof payloadValue === "string") {
+        try {
+            payload = JSON.parse(payloadValue);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isRecord(payload))
+        return null;
+    return payload;
+}
+export function extractSlackBlockActionsPayloadFromEnvelope(envelope) {
+    const payload = extractSlackInteractivePayloadFromEnvelope(envelope);
+    return payload?.type === "block_actions" ? payload : null;
+}
+export function normalizeSlackBlockActionPayload(payload) {
+    const user = asRecord(payload.user);
+    const container = asRecord(payload.container);
+    const channel = asRecord(payload.channel);
+    const message = asRecord(payload.message);
+    const view = asRecord(payload.view);
+    const actions = Array.isArray(payload.actions)
+        ? payload.actions
+            .map((entry) => asRecord(entry))
+            .filter((entry) => Boolean(entry))
+        : [];
+    const normalizedActions = actions
+        .map(normalizeAction)
+        .filter((action) => Boolean(action));
+    if (normalizedActions.length === 0)
+        return null;
+    const modalMetadata = decodeSlackModalPrivateMetadata(asString(view?.private_metadata));
+    const channelId = asString(container?.channel_id) ??
+        asString(channel?.id) ??
+        asString(message?.channel?.id) ??
+        modalMetadata.threadContext?.channel;
+    const messageTs = asString(container?.message_ts) ?? asString(message?.ts);
+    const threadTs = asString(container?.thread_ts) ??
+        asString(message?.thread_ts) ??
+        messageTs ??
+        modalMetadata.threadContext?.threadTs;
+    const userId = asString(user?.id);
+    if (!channelId || !threadTs || !userId)
+        return null;
+    const primaryAction = normalizedActions[0];
+    const label = primaryAction.text?.trim() ? `"${primaryAction.text.trim()}"` : "button";
+    const timestamp = primaryAction.actionTs ??
+        asString(payload.action_ts) ??
+        asString(view?.hash) ??
+        messageTs ??
+        threadTs;
+    return {
+        channel: channelId,
+        threadTs,
+        userId,
+        text: `Clicked Slack ${label} (action_id: ${primaryAction.actionId}).`,
+        timestamp,
+        metadata: {
+            kind: "slack_block_action",
+            triggerId: asString(payload.trigger_id) ?? null,
+            viewId: asString(view?.id) ?? null,
+            callbackId: asString(view?.callback_id) ?? null,
+            viewHash: asString(view?.hash) ?? null,
+            blockId: primaryAction.blockId ?? null,
+            actionId: primaryAction.actionId,
+            value: primaryAction.value ?? null,
+            parsedValue: primaryAction.parsedValue ?? null,
+            actionText: primaryAction.text ?? null,
+            channel: channelId,
+            threadTs,
+            messageTs: messageTs ?? null,
+            modalPrivateMetadata: modalMetadata.value ?? null,
+            actions: sanitizeNormalizedActions(normalizedActions),
+        },
+    };
+}
+export function normalizeSlackViewSubmissionPayload(payload) {
+    if (payload.type !== "view_submission") {
+        return null;
+    }
+    const user = asRecord(payload.user);
+    const view = asRecord(payload.view);
+    const state = asRecord(view?.state);
+    const stateValues = asRecord(state?.values);
+    const userId = asString(user?.id);
+    const viewId = asString(view?.id);
+    const modalMetadata = decodeSlackModalPrivateMetadata(asString(view?.private_metadata));
+    const threadTs = modalMetadata.threadContext?.threadTs;
+    const channel = modalMetadata.threadContext?.channel;
+    if (!userId || !threadTs || !channel || !viewId || !stateValues) {
+        return null;
+    }
+    const normalizedValues = {};
+    for (const [blockId, rawActions] of Object.entries(stateValues)) {
+        const actionMap = asRecord(rawActions);
+        if (!actionMap)
+            continue;
+        normalizedValues[blockId] = Object.fromEntries(Object.entries(actionMap).map(([actionId, rawValue]) => [
+            actionId,
+            normalizeViewStateValue(asRecord(rawValue) ?? {}),
+        ]));
+    }
+    const callbackId = asString(view?.callback_id);
+    const titleText = asString((asRecord(view?.title) ?? {}).text);
+    const timestamp = asString(payload.hash) ?? viewId;
+    return {
+        channel,
+        threadTs,
+        userId,
+        text: `Submitted Slack modal ${callbackId ? `(${callbackId}) ` : ""}${titleText ? `"${titleText}"` : `view ${viewId}`}.`,
+        timestamp,
+        metadata: {
+            kind: "slack_view_submission",
+            triggerId: asString(payload.trigger_id) ?? null,
+            callbackId: callbackId ?? null,
+            viewId,
+            externalId: asString(view?.external_id) ?? null,
+            viewHash: asString(view?.hash) ?? null,
+            channel,
+            threadTs,
+            privateMetadata: modalMetadata.value ?? null,
+            stateValues: normalizedValues,
+        },
+    };
+}

package/dist/slack-export.d.ts

@@ -0,0 +1,31 @@
+export type SlackExportFormat = "markdown" | "json" | "plain";
+export interface SlackExportFileInput {
+    name?: string;
+    title?: string;
+    mimetype?: string;
+    filetype?: string;
+    permalink?: string;
+    urlPrivate?: string;
+    preview?: string;
+}
+export interface SlackExportMessageInput {
+    ts?: string;
+    authorName?: string;
+    text?: string;
+    files?: SlackExportFileInput[];
+}
+export interface BuildSlackThreadExportOptions {
+    format?: string;
+    includeMetadata?: boolean;
+    threadTs: string;
+    channelId: string;
+    channelLabel?: string;
+    messages: SlackExportMessageInput[];
+    mentionNames?: Record<string, string>;
+}
+export declare function convertSlackMrkdwnToMarkdown(text: string, mentionNames?: Record<string, string>): string;
+export declare function normalizeSlackExportFormat(format?: string): SlackExportFormat;
+export declare function parseSlackExportBoundaryTs(value: string): number;
+export declare function filterSlackExportMessagesByRange(messages: SlackExportMessageInput[], oldestTs?: number, latestTs?: number): SlackExportMessageInput[];
+export declare function formatSlackExportTimestamp(ts?: string): string;
+export declare function buildSlackThreadExport(options: BuildSlackThreadExportOptions): string;

package/dist/slack-export.js

@@ -0,0 +1,206 @@
+function decodeSlackEntities(text) {
+    return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function formatSlackToken(token, mentionNames) {
+    if (token.startsWith("@")) {
+        const userId = token.slice(1);
+        return `@${mentionNames[userId] ?? userId}`;
+    }
+    if (token.startsWith("#")) {
+        const [, fallback] = token.split("|");
+        return `#${fallback ?? token.slice(1)}`;
+    }
+    if (token.startsWith("!")) {
+        if (token === "!here" || token === "!channel" || token === "!everyone") {
+            return `@${token.slice(1)}`;
+        }
+        if (token.startsWith("!subteam^")) {
+            const [, handle] = token.split("|");
+            return `@${handle ?? "group"}`;
+        }
+        if (token.startsWith("!date^")) {
+            const [, fallback] = token.split("|");
+            return fallback ?? token;
+        }
+        return token.slice(1);
+    }
+    const [target, label] = token.split("|");
+    if (!target) {
+        return token;
+    }
+    if (target.startsWith("mailto:")) {
+        const visible = label ?? target.slice("mailto:".length);
+        return `[${visible}](${target})`;
+    }
+    if (target.startsWith("http://") || target.startsWith("https://")) {
+        const visible = label ?? target;
+        return `[${visible}](${target})`;
+    }
+    return label ?? target;
+}
+export function convertSlackMrkdwnToMarkdown(text, mentionNames = {}) {
+    const decoded = decodeSlackEntities(text);
+    const withTokens = decoded.replace(/<([^>]+)>/g, (_match, token) => formatSlackToken(token, mentionNames));
+    return withTokens
+        .replace(/(^|[\s(])\*(\S(?:[\s\S]*?\S)?)\*(?=$|[\s).,!?:;])/g, "$1**$2**")
+        .replace(/(^|[\s(])~(\S(?:[\s\S]*?\S)?)~(?=$|[\s).,!?:;])/g, "$1~~$2~~");
+}
+export function normalizeSlackExportFormat(format) {
+    const normalized = format?.trim().toLowerCase() ?? "markdown";
+    if (normalized === "markdown" || normalized === "json" || normalized === "plain") {
+        return normalized;
+    }
+    throw new Error("format must be 'markdown', 'json', or 'plain'.");
+}
+export function parseSlackExportBoundaryTs(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("Timestamp boundary cannot be empty.");
+    }
+    if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        return Number.parseFloat(trimmed);
+    }
+    const parsed = Date.parse(trimmed);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid timestamp boundary: ${value}`);
+    }
+    return parsed / 1000;
+}
+export function filterSlackExportMessagesByRange(messages, oldestTs, latestTs) {
+    return messages.filter((message) => {
+        const ts = message.ts ? Number.parseFloat(message.ts) : Number.NaN;
+        if (!Number.isFinite(ts)) {
+            return true;
+        }
+        if (oldestTs != null && ts < oldestTs) {
+            return false;
+        }
+        if (latestTs != null && ts > latestTs) {
+            return false;
+        }
+        return true;
+    });
+}
+export function formatSlackExportTimestamp(ts) {
+    if (!ts) {
+        return "unknown time";
+    }
+    const numeric = Number.parseFloat(ts);
+    if (!Number.isFinite(numeric)) {
+        return ts;
+    }
+    return new Date(numeric * 1000).toISOString();
+}
+function buildSlackFileSummary(file) {
+    const label = file.title ?? file.name ?? "attachment";
+    const url = file.permalink ?? file.urlPrivate;
+    const type = file.filetype ?? file.mimetype;
+    const parts = [`- ${label}`];
+    if (type) {
+        parts.push(`(${type})`);
+    }
+    if (url) {
+        parts.push(`— ${url}`);
+    }
+    let line = parts.join(" ");
+    const preview = file.preview?.trim();
+    if (preview) {
+        line += `\n  Preview: ${preview}`;
+    }
+    return line;
+}
+function buildSlackExportHeader(options, participants) {
+    const header = ["# Slack Thread Export", ""];
+    header.push(`- Thread: \`${options.threadTs}\``);
+    header.push(options.channelLabel
+        ? `- Channel: ${options.channelLabel} (\`${options.channelId}\`)`
+        : `- Channel: \`${options.channelId}\``);
+    header.push(`- Messages: ${options.messages.length}`);
+    if (participants.length > 0) {
+        header.push(`- Participants: ${participants.join(", ")}`);
+    }
+    header.push("");
+    return header;
+}
+function buildMarkdownExport(options) {
+    const mentionNames = options.mentionNames ?? {};
+    const participants = [
+        ...new Set(options.messages.map((message) => message.authorName).filter(Boolean)),
+    ];
+    const lines = buildSlackExportHeader(options, participants);
+    options.messages.forEach((message, index) => {
+        const heading = options.includeMetadata !== false
+            ? `## ${formatSlackExportTimestamp(message.ts)} — ${message.authorName ?? "unknown"}`
+            : `## Message ${index + 1}`;
+        lines.push(heading, "");
+        const body = convertSlackMrkdwnToMarkdown(message.text ?? "", mentionNames).trim();
+        lines.push(body || "(no text)");
+        if ((message.files?.length ?? 0) > 0) {
+            lines.push("", "Attachments:");
+            for (const file of message.files ?? []) {
+                lines.push(buildSlackFileSummary(file));
+            }
+        }
+        lines.push("", "---", "");
+    });
+    return lines.join("\n").trim();
+}
+function buildPlainExport(options) {
+    const mentionNames = options.mentionNames ?? {};
+    const lines = [];
+    for (const message of options.messages) {
+        if (options.includeMetadata !== false) {
+            lines.push(`[${formatSlackExportTimestamp(message.ts)}] ${message.authorName ?? "unknown"}`);
+        }
+        lines.push(convertSlackMrkdwnToMarkdown(message.text ?? "", mentionNames).trim() || "(no text)");
+        if ((message.files?.length ?? 0) > 0) {
+            lines.push("Attachments:");
+            for (const file of message.files ?? []) {
+                lines.push(buildSlackFileSummary(file));
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function buildJsonExport(options) {
+    const mentionNames = options.mentionNames ?? {};
+    const payload = {
+        format: "json",
+        thread_ts: options.threadTs,
+        channel: options.channelId,
+        channel_label: options.channelLabel,
+        include_metadata: options.includeMetadata !== false,
+        message_count: options.messages.length,
+        messages: options.messages.map((message, index) => ({
+            index: index + 1,
+            ...(options.includeMetadata !== false
+                ? {
+                    ts: message.ts,
+                    timestamp: formatSlackExportTimestamp(message.ts),
+                    author: message.authorName ?? "unknown",
+                }
+                : {}),
+            text: convertSlackMrkdwnToMarkdown(message.text ?? "", mentionNames),
+            files: (message.files ?? []).map((file) => ({
+                title: file.title,
+                name: file.name,
+                type: file.filetype ?? file.mimetype,
+                permalink: file.permalink,
+                url_private: file.urlPrivate,
+                preview: file.preview,
+            })),
+        })),
+    };
+    return JSON.stringify(payload, null, 2);
+}
+export function buildSlackThreadExport(options) {
+    const format = normalizeSlackExportFormat(options.format);
+    if (format === "json") {
+        return buildJsonExport(options);
+    }
+    if (format === "plain") {
+        return buildPlainExport(options);
+    }
+    return buildMarkdownExport(options);
+}

package/dist/slack-message-context.d.ts

@@ -0,0 +1,15 @@
+export interface SlackMessageFileMetadata {
+    id?: string;
+    name?: string;
+    title?: string;
+    mimetype?: string;
+    filetype?: string;
+    prettyType?: string;
+    permalink?: string;
+    urlPrivate?: string;
+    mode?: string;
+    size?: number;
+}
+export declare function extractSlackMessageFileMetadata(files: unknown): SlackMessageFileMetadata[];
+export declare function extractSlackMessageContextLines(evt: Record<string, unknown>, baseText?: string): string[];
+export declare function buildSlackInboundMessageText(baseText: string, evt: Record<string, unknown>): string;

package/dist/slack-message-context.js

@@ -0,0 +1,207 @@
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asRecordArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "object" && item !== null)
+        : [];
+}
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function clipLine(value, maxLength = 220) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength - 1).trimEnd()}…`;
+}
+function pushContextLine(lines, rawValue) {
+    if (!rawValue)
+        return;
+    const normalized = clipLine(normalizeWhitespace(rawValue));
+    if (!normalized)
+        return;
+    lines.push(normalized);
+}
+function extractTextObject(value) {
+    const record = asRecord(value);
+    if (!record)
+        return [];
+    const text = asString(record.text);
+    return text ? [text] : [];
+}
+function extractRichTextElementText(element) {
+    const type = asString(element.type) ?? "";
+    switch (type) {
+        case "text": {
+            const text = asString(element.text);
+            return text ? [text] : [];
+        }
+        case "link": {
+            const text = asString(element.text);
+            const url = asString(element.url);
+            if (text && url && text !== url) {
+                return [`${text} (${url})`];
+            }
+            return text ? [text] : url ? [url] : [];
+        }
+        case "emoji": {
+            const name = asString(element.name);
+            return name ? [`:${name}:`] : [];
+        }
+        case "user": {
+            const userId = asString(element.user_id);
+            return userId ? [`<@${userId}>`] : [];
+        }
+        case "channel": {
+            const channelId = asString(element.channel_id);
+            return channelId ? [`<#${channelId}>`] : [];
+        }
+        case "rich_text_section":
+        case "rich_text_list":
+        case "rich_text_quote":
+        case "rich_text_preformatted": {
+            return asRecordArray(element.elements).flatMap((child) => extractRichTextElementText(child));
+        }
+        default:
+            return [];
+    }
+}
+function extractBlockContextLines(blocks) {
+    const lines = [];
+    for (const block of asRecordArray(blocks)) {
+        const type = asString(block.type) ?? "";
+        switch (type) {
+            case "header":
+            case "section": {
+                for (const value of extractTextObject(block.text)) {
+                    pushContextLine(lines, value);
+                }
+                for (const field of asRecordArray(block.fields)) {
+                    for (const value of extractTextObject(field)) {
+                        pushContextLine(lines, value);
+                    }
+                }
+                break;
+            }
+            case "context": {
+                for (const element of asRecordArray(block.elements)) {
+                    for (const value of extractTextObject(element)) {
+                        pushContextLine(lines, value);
+                    }
+                }
+                break;
+            }
+            case "image": {
+                pushContextLine(lines, asString(block.alt_text));
+                break;
+            }
+            case "rich_text": {
+                for (const element of asRecordArray(block.elements)) {
+                    const text = extractRichTextElementText(element).join("");
+                    pushContextLine(lines, text);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return lines;
+}
+function extractAttachmentContextLines(attachments) {
+    const lines = [];
+    for (const attachment of asRecordArray(attachments)) {
+        pushContextLine(lines, asString(attachment.pretext));
+        pushContextLine(lines, asString(attachment.title));
+        pushContextLine(lines, asString(attachment.text));
+        pushContextLine(lines, asString(attachment.fallback));
+        pushContextLine(lines, asString(attachment.footer));
+        lines.push(...extractBlockContextLines(attachment.blocks));
+    }
+    return lines;
+}
+export function extractSlackMessageFileMetadata(files) {
+    const extracted = [];
+    for (const file of asRecordArray(files)) {
+        const metadata = {
+            ...(asString(file.id) ? { id: asString(file.id) ?? undefined } : {}),
+            ...(asString(file.name) ? { name: asString(file.name) ?? undefined } : {}),
+            ...(asString(file.title) ? { title: asString(file.title) ?? undefined } : {}),
+            ...(asString(file.mimetype) ? { mimetype: asString(file.mimetype) ?? undefined } : {}),
+            ...(asString(file.filetype) ? { filetype: asString(file.filetype) ?? undefined } : {}),
+            ...(asString(file.pretty_type)
+                ? { prettyType: asString(file.pretty_type) ?? undefined }
+                : {}),
+            ...(asString(file.permalink) ? { permalink: asString(file.permalink) ?? undefined } : {}),
+            ...(asString(file.url_private_download)
+                ? { urlPrivate: asString(file.url_private_download) ?? undefined }
+                : asString(file.url_private)
+                    ? { urlPrivate: asString(file.url_private) ?? undefined }
+                    : {}),
+            ...(asString(file.mode) ? { mode: asString(file.mode) ?? undefined } : {}),
+            ...(typeof file.size === "number" ? { size: file.size } : {}),
+        };
+        if (Object.keys(metadata).length === 0)
+            continue;
+        extracted.push(metadata);
+    }
+    return extracted;
+}
+function extractFileContextLines(files) {
+    const lines = [];
+    for (const file of extractSlackMessageFileMetadata(files)) {
+        const title = file.title ?? file.name;
+        const prettyType = file.prettyType ?? file.filetype ?? file.mimetype;
+        const parts = [
+            title,
+            prettyType,
+            file.mode,
+            file.id ? `id=${file.id}` : null,
+            file.permalink ?? file.urlPrivate ?? null,
+        ].filter((part) => Boolean(part));
+        if (parts.length === 0)
+            continue;
+        pushContextLine(lines, parts.join(" — "));
+    }
+    return lines;
+}
+function dedupeContextLines(baseText, lines) {
+    const baseNormalized = normalizeWhitespace(baseText).toLowerCase();
+    const seen = new Set();
+    const deduped = [];
+    for (const line of lines) {
+        const normalized = normalizeWhitespace(line).toLowerCase();
+        if (!normalized)
+            continue;
+        if (baseNormalized && normalized === baseNormalized) {
+            continue;
+        }
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        deduped.push(line);
+    }
+    return deduped;
+}
+export function extractSlackMessageContextLines(evt, baseText = "") {
+    const lines = [
+        ...extractBlockContextLines(evt.blocks),
+        ...extractAttachmentContextLines(evt.attachments),
+        ...extractFileContextLines(evt.files),
+    ];
+    return dedupeContextLines(baseText, lines).slice(0, 4);
+}
+export function buildSlackInboundMessageText(baseText, evt) {
+    const trimmedBase = baseText.trim();
+    const contextLines = extractSlackMessageContextLines(evt, trimmedBase);
+    if (contextLines.length === 0) {
+        return trimmedBase;
+    }
+    const prefix = trimmedBase.length > 0 ? trimmedBase : "(Slack message had no plain-text body)";
+    return `${prefix}\n\nSlack message context:\n${contextLines.map((line) => `- ${line}`).join("\n")}`;
+}