@credal/actions 0.2.153 → 0.2.155

package/dist/actions/providers/slack/messageTransformers.js

@@ -0,0 +1,267 @@
+/**
+ * Get the highest quality thumbnail from a file
+ */
+export function getHighestQualityThumb(file) {
+    const thumbSizes = [
+        "thumb_1024",
+        "thumb_960",
+        "thumb_800",
+        "thumb_720",
+        "thumb_480",
+        "thumb_360",
+        "thumb_160",
+        "thumb_80",
+        "thumb_64",
+    ];
+    for (const size of thumbSizes) {
+        const thumb = file[size];
+        if (thumb && typeof thumb === "string") {
+            return thumb;
+        }
+    }
+    return undefined;
+}
+/**
+ * Simplify file objects to only include essential fields and highest quality thumbnail
+ */
+export function simplifyFile(file) {
+    const simplified = {
+        id: file.id,
+        created: file.created,
+        timestamp: file.timestamp,
+        name: file.name,
+        title: file.title,
+        mimetype: file.mimetype,
+        file_access: file.file_access,
+    };
+    const highestThumb = getHighestQualityThumb(file);
+    if (highestThumb) {
+        simplified.highest_thumb = highestThumb;
+    }
+    return simplified;
+}
+// Redundant fields to remove from messages - not useful (fills up context window so we can ditch these)
+const REDUNDANT_FIELDS = [
+    // Image/media metadata
+    "app_icons",
+    "image_width",
+    "image_height",
+    "image_bytes",
+    "fallback",
+    "is_animated",
+    // Message metadata (not content-related)
+    "team",
+    "client_msg_id",
+    "is_locked",
+    "subscribed",
+    "display_as_bot",
+    "upload",
+    // Block metadata
+    "block_id",
+    "unicode", // Emoji unicode values (name is sufficient)
+    // File metadata (duplicates or not useful)
+    "file_access",
+    "filetype", // Redundant with mimetype
+    "pretty_type", // Redundant with mimetype
+    "thumb_tiny", // Base64 preview, not needed
+    // Attachment metadata
+    "service_icon", // Icon URLs for link previews
+    "from_url", // Duplicate of original_url
+];
+/**
+ * Recursively remove redundant fields from an object to reduce payload size
+ */
+export function removeRedundantFields(obj) {
+    for (const key of REDUNDANT_FIELDS) {
+        delete obj[key];
+    }
+    // Recursively clean nested objects and arrays
+    for (const key in obj) {
+        const value = obj[key];
+        if (value && typeof value === "object") {
+            if (Array.isArray(value)) {
+                value.forEach(item => {
+                    if (item && typeof item === "object") {
+                        removeRedundantFields(item);
+                    }
+                });
+            }
+            else {
+                removeRedundantFields(value);
+            }
+        }
+    }
+}
+/**
+ * Extracts all visible text from a Slack message
+ */
+export function extractMessageText(m) {
+    var _a, _b, _c, _d;
+    if (!m)
+        return undefined;
+    const pieces = [];
+    // ---- Rich text helpers ----
+    const walkRichTextInline = (el) => {
+        var _a;
+        const blockPieces = [];
+        switch (el.type) {
+            case "text":
+                blockPieces.push(el.text);
+                break;
+            case "link":
+                blockPieces.push(el.text || el.url);
+                break;
+            case "user":
+                blockPieces.push(`<@${el.user_id}>`);
+                break;
+            case "channel":
+                blockPieces.push(`<#${el.channel_id}>`);
+                break;
+            case "emoji":
+                blockPieces.push(`:${el.name}:`);
+                break;
+            case "broadcast":
+                blockPieces.push(`@${el.range}`);
+                break;
+            case "date":
+                blockPieces.push((_a = el.fallback) !== null && _a !== void 0 ? _a : `<date:${el.timestamp}>`);
+                break;
+            case "team":
+                blockPieces.push(`<team:${el.team_id}>`);
+                break;
+            case "usergroup":
+                blockPieces.push(`<usergroup:${el.usergroup_id}>`);
+                break;
+            case "color":
+                // Usually formatting only, skip
+                break;
+        }
+        return blockPieces;
+    };
+    const walkRichTextElement = (el) => {
+        const result = [];
+        switch (el.type) {
+            case "rich_text_section":
+            case "rich_text_quote":
+                result.push(el.elements.map(walkRichTextInline).join("\n"));
+                break;
+            case "rich_text_list":
+                result.push(el.elements.map(section => section.elements.map(walkRichTextInline).join("\n")).join("\n"));
+                break;
+            case "rich_text_preformatted":
+                result.push(el.elements.map(walkRichTextInline).join("\n"));
+                break;
+        }
+        return result;
+    };
+    // ---- Block helpers ----
+    const walkBlock = (block) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const blockPieces = [];
+        switch (block.type) {
+            case "section":
+                if ((_a = block.text) === null || _a === void 0 ? void 0 : _a.text)
+                    blockPieces.push(block.text.text);
+                if (block.fields) {
+                    for (const f of block.fields)
+                        if (f.text)
+                            blockPieces.push(f.text);
+                }
+                if (block.accessory && "text" in block.accessory && block.accessory.text) {
+                    blockPieces.push(block.accessory.text.text);
+                }
+                break;
+            case "context":
+                if (Array.isArray(block.elements)) {
+                    block.elements.forEach(el => {
+                        if ("text" in el && el.text)
+                            blockPieces.push(el.text);
+                    });
+                }
+                break;
+            case "header":
+                if ((_b = block.text) === null || _b === void 0 ? void 0 : _b.text)
+                    blockPieces.push(block.text.text);
+                break;
+            case "rich_text":
+                blockPieces.push(block.elements.map(walkRichTextElement).join("\n"));
+                break;
+            case "markdown":
+                if (block.text)
+                    blockPieces.push(block.text);
+                break;
+            case "video":
+                if ((_c = block.title) === null || _c === void 0 ? void 0 : _c.text)
+                    blockPieces.push(block.title.text);
+                if ((_d = block.description) === null || _d === void 0 ? void 0 : _d.text)
+                    blockPieces.push(block.description.text);
+                break;
+            case "image":
+                if ((_e = block.title) === null || _e === void 0 ? void 0 : _e.text)
+                    blockPieces.push(block.title.text);
+                break;
+            case "input":
+                if ((_f = block.label) === null || _f === void 0 ? void 0 : _f.text)
+                    blockPieces.push(block.label.text);
+                if ((_g = block.hint) === null || _g === void 0 ? void 0 : _g.text)
+                    blockPieces.push(block.hint.text);
+                break;
+            // divider, file, actions, input don't contribute visible text
+            case "divider":
+            case "file":
+            case "actions":
+                break;
+        }
+        return blockPieces;
+    };
+    let blockText = "";
+    if (Array.isArray(m.blocks)) {
+        const blockPieces = m.blocks.map(b => walkBlock(b));
+        blockText = blockPieces.join("\n");
+    }
+    if (blockText) {
+        pieces.push(blockText);
+    }
+    else if (m.text) {
+        pieces.push(m.text);
+    }
+    // 3. Attachments
+    if (m.attachments) {
+        for (const att of m.attachments) {
+            if (att.pretext)
+                pieces.push(att.pretext);
+            if (att.title)
+                pieces.push(att.title);
+            if (att.text)
+                pieces.push(att.text);
+            if (att.fields) {
+                for (const f of att.fields) {
+                    const title = (_b = (_a = f.title) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
+                    const value = (_d = (_c = f.value) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : "";
+                    if (title || value) {
+                        pieces.push(title && value ? `${title}: ${value}` : title || value);
+                    }
+                }
+            }
+        }
+    }
+    // Deduplicate and join
+    const out = Array.from(new Set(pieces.map(s => s.trim()).filter(Boolean))).join("\n");
+    return out || undefined;
+}
+/**
+ * Transforms a Slack MessageElement to a simplified SlackMessage
+ */
+export function transformToSlackMessage(message) {
+    return {
+        ts: message.ts,
+        text: message.text,
+        user: message.user,
+        username: message.username,
+        thread_ts: message.thread_ts,
+        blocks: message.blocks,
+        attachments: message.attachments,
+        reactions: message.reactions,
+        files: message.files,
+    };
+}

package/dist/actions/providers/slackUser/getSlackMessagesInTimeRange.d.ts

@@ -0,0 +1,3 @@
+import { type slackUserGetSlackMessagesInTimeRangeFunction } from "../../autogen/types.js";
+declare const getSlackMessagesInTimeRange: slackUserGetSlackMessagesInTimeRangeFunction;
+export default getSlackMessagesInTimeRange;

package/dist/actions/providers/slackUser/getSlackMessagesInTimeRange.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { WebClient } from "@slack/web-api";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { extractMessageText, SlackUserCache, normalizeChannelOperand } from "./searchSlack.js";
+/* ===================== Helpers ===================== */
+function searchMessagesInTimeRange(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { client, channel, oldest, latest, limit } = input;
+        // Build search query - use wildcard to match all messages
+        const parts = [`in:${normalizeChannelOperand(channel)}`];
+        if (oldest) {
+            parts.push(`after:${oldest}`);
+        }
+        if (latest) {
+            parts.push(`before:${latest}`);
+        }
+        // Use * as a wildcard to match all messages
+        const query = parts.join(" ") + " *";
+        const searchRes = yield client.search.messages({ query, count: limit, highlight: true });
+        return (_b = (_a = searchRes.messages) === null || _a === void 0 ? void 0 : _a.matches) !== null && _b !== void 0 ? _b : [];
+    });
+}
+/* ===================== MAIN EXPORT ===================== */
+const getSlackMessagesInTimeRange = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken)
+        throw new Error(MISSING_AUTH_TOKEN);
+    const client = new WebClient(authParams.authToken);
+    const cache = new SlackUserCache(client);
+    const { channel, oldest, limit = 50 } = params;
+    let { latest } = params;
+    // Ensure latest doesn't exceed current time
+    const now = Math.floor(Date.now() / 1000);
+    if (latest && latest > now) {
+        latest = now;
+    }
+    const { user_id: myUserId } = yield client.auth.test();
+    if (!myUserId)
+        throw new Error("Failed to get my user ID.");
+    const meInfo = yield cache.get(myUserId);
+    // Search for messages in the channel using search API
+    const matches = yield searchMessagesInTimeRange({ client, channel, oldest, latest, limit });
+    // Convert matches to results
+    const results = yield Promise.all(matches.map((m) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (!m.ts || !((_a = m.channel) === null || _a === void 0 ? void 0 : _a.id))
+            return null;
+        // Get user info for the message author
+        const userId = (_b = m.user) !== null && _b !== void 0 ? _b : m.username;
+        const userInfo = userId ? yield cache.get(userId) : undefined;
+        // Extract text from the match
+        const text = (_d = (_c = extractMessageText(m)) !== null && _c !== void 0 ? _c : m.text) !== null && _d !== void 0 ? _d : "";
+        return {
+            channelId: m.channel.id,
+            ts: m.ts,
+            text,
+            userEmail: userInfo === null || userInfo === void 0 ? void 0 : userInfo.email,
+            userName: userInfo === null || userInfo === void 0 ? void 0 : userInfo.name,
+            permalink: m.permalink,
+        };
+    })));
+    // Filter out nulls and sort by timestamp descending
+    const validResults = results.filter(Boolean).sort((a, b) => Number(b.ts) - Number(a.ts));
+    return {
+        results: validResults.map(r => ({
+            name: r.text || "Untitled",
+            url: r.permalink || "",
+            contents: r,
+        })),
+        currentUser: { userId: myUserId, userName: meInfo === null || meInfo === void 0 ? void 0 : meInfo.name, userEmail: meInfo === null || meInfo === void 0 ? void 0 : meInfo.email },
+    };
+});
+export default getSlackMessagesInTimeRange;

package/dist/actions/providers/slackUser/searchSlack.d.ts

@@ -1,6 +1,4 @@
-import { type KnownBlock } from "@slack/web-api";
 import { type slackUserSearchSlackFunction } from "../../autogen/types.js";
-import type { Attachment } from "@slack/web-api/dist/types/response/ChannelsHistoryResponse.js";
 export type TimeRange = "latest" | "today" | "yesterday" | "last_7d" | "last_30d" | "all";
 export interface SlackSearchMessage {
     channelId: string;
@@ -21,18 +19,5 @@ export interface SlackSearchMessage {
         userName?: string;
     }>;
 }
-interface SlackMessage {
-    ts?: string;
-    text?: string;
-    user?: string;
-    username?: string;
-    thread_ts?: string;
-    blocks?: KnownBlock[];
-    attachments?: Attachment[];
-}
-/**
- * Extracts all visible text from a Slack message
- */
-export declare function extractMessageText(m: SlackMessage | undefined): string | undefined;
 declare const searchSlack: slackUserSearchSlackFunction;
 export default searchSlack;