@credal/actions 0.2.154 → 0.2.156

package/dist/actions/providers/jira/getJiraIssuesByQuery.js

@@ -10,6 +10,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { axiosClient } from "../../util/axiosClient.js";
 import { getJiraApiConfig, getErrorMessage } from "./utils.js";
 const DEFAULT_LIMIT = 100;
+function extractPlainText(adf) {
+    if (!adf || adf.type !== "doc" || !Array.isArray(adf.content))
+        return "";
+    return adf.content
+        .map(block => {
+        if (block.type === "paragraph" && Array.isArray(block.content)) {
+            return block.content.map(inline => { var _a; return (_a = inline.text) !== null && _a !== void 0 ? _a : ""; }).join("");
+        }
+        return "";
+    })
+        .join("\n")
+        .trim();
+}
 const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
     const { authToken } = authParams;
     const { query, limit } = params;
@@ -17,9 +30,6 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
     if (!authToken) {
         throw new Error("Auth token is required");
     }
-    const queryParams = new URLSearchParams();
-    queryParams.set("jql", query);
-    queryParams.set("maxResults", String(limit != undefined && limit <= DEFAULT_LIMIT ? limit : DEFAULT_LIMIT));
     const fields = [
         "key",
         "id",
@@ -39,19 +49,37 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
         "timespent",
         "aggregatetimeoriginalestimate",
     ];
-    queryParams.set("fields", fields.join(","));
     const searchEndpoint = strategy.getSearchEndpoint();
-    const fullApiUrl = `${apiUrl}${searchEndpoint}?${queryParams.toString()}`;
+    const requestedLimit = limit !== null && limit !== void 0 ? limit : DEFAULT_LIMIT;
+    const allIssues = [];
+    let startAt = 0;
     try {
-        const response = yield axiosClient.get(fullApiUrl, {
-            headers: {
-                Authorization: `Bearer ${authToken}`,
-                Accept: "application/json",
-            },
-        });
+        // Keep fetching pages until we have all requested issues
+        while (allIssues.length < requestedLimit) {
+            // Calculate how many results to fetch in this request
+            const remainingIssues = requestedLimit - allIssues.length;
+            const maxResults = Math.min(remainingIssues, DEFAULT_LIMIT);
+            const queryParams = new URLSearchParams();
+            queryParams.set("jql", query);
+            queryParams.set("maxResults", String(maxResults));
+            queryParams.set("startAt", String(startAt));
+            queryParams.set("fields", fields.join(","));
+            const fullApiUrl = `${apiUrl}${searchEndpoint}?${queryParams.toString()}`;
+            const response = yield axiosClient.get(fullApiUrl, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    Accept: "application/json",
+                },
+            });
+            const { issues, total } = response.data;
+            allIssues.push(...issues);
+            if (allIssues.length >= total || issues.length === 0) {
+                break;
+            }
+            startAt += issues.length;
+        }
         return {
-            success: true,
-            results: response.data.issues.map(issue => {
+            results: allIssues.map(issue => {
                 const { id, key, fields } = issue;
                 const { summary, description, project, issuetype, status, assignee, reporter, creator, created, updated, resolution, duedate, } = fields;
                 const ticketUrl = `${browseUrl}/browse/${key}`;
@@ -93,22 +121,9 @@ const getJiraIssuesByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* (
     catch (error) {
         console.error("Error retrieving Jira issues:", error);
         return {
-            success: false,
+            results: [],
             error: getErrorMessage(error),
         };
     }
 });
-function extractPlainText(adf) {
-    if (!adf || adf.type !== "doc" || !Array.isArray(adf.content))
-        return "";
-    return adf.content
-        .map(block => {
-        if (block.type === "paragraph" && Array.isArray(block.content)) {
-            return block.content.map(inline => { var _a; return (_a = inline.text) !== null && _a !== void 0 ? _a : ""; }).join("");
-        }
-        return "";
-    })
-        .join("\n")
-        .trim();
-}
 export default getJiraIssuesByQuery;

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

@@ -10,12 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { WebClient } from "@slack/web-api";
 import { getSlackChannels } from "./helpers.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { extractMessageText, transformToSlackMessage, simplifyFile, removeRedundantFields, } from "./messageTransformers.js";
 const getChannelMessages = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
     if (!authParams.authToken) {
         throw new Error(MISSING_AUTH_TOKEN);
     }
     const client = new WebClient(authParams.authToken);
-    const { channelId: inputChannelId, channelName, oldest } = params;
+    const { channelId: inputChannelId, channelName, oldest, latest, limit, cursor, includeThreadReplies } = params;
     if (!inputChannelId && !channelName) {
         throw Error("Either channelId or channelName must be provided");
     }
@@ -31,12 +33,106 @@ const getChannelMessages = (_a) => __awaiter(void 0, [_a], void 0, function* ({
     const messages = yield client.conversations.history({
         channel: channelId,
         oldest: oldest,
+        latest: latest,
+        limit: limit,
+        cursor: cursor,
     });
     if (!messages.ok) {
         throw Error(`Failed to fetch messages from channel ${channelName}, channelId: ${channelId}`);
     }
+    let processedMessages = messages.messages;
+    // Fetch thread replies if requested
+    if (includeThreadReplies) {
+        processedMessages = yield Promise.all(processedMessages.map((msg) => __awaiter(void 0, void 0, void 0, function* () {
+            // If message has replies, fetch them
+            if (msg.reply_count && msg.reply_count > 0 && msg.ts) {
+                try {
+                    const threadReplies = yield client.conversations.replies({
+                        channel: channelId,
+                        ts: msg.ts,
+                        limit: 20,
+                    });
+                    if (threadReplies.ok && threadReplies.messages) {
+                        // Skip the first message (it's the parent) and process replies
+                        const replies = threadReplies.messages.slice(1);
+                        // Process each reply: extract text, simplify files, simplify reactions, remove redundant fields
+                        msg.replies = replies.map(reply => {
+                            // Extract text from reply
+                            const replyTransformed = transformToSlackMessage(reply);
+                            const replyExtractedText = extractMessageText(replyTransformed);
+                            if (replyExtractedText) {
+                                reply.extractedText = replyExtractedText;
+                            }
+                            // Simplify files in reply
+                            if (reply.files && Array.isArray(reply.files)) {
+                                reply.files = reply.files.map((file) => simplifyFile(file));
+                            }
+                            // Simplify reactions in reply
+                            if (reply.reactions && Array.isArray(reply.reactions)) {
+                                reply.reactions = reply.reactions.map((reaction) => ({
+                                    name: reaction.name,
+                                    count: reaction.count,
+                                }));
+                            }
+                            // Remove redundant fields from reply
+                            removeRedundantFields(reply);
+                            return reply;
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to fetch replies for message ${msg.ts}:`, error);
+                }
+            }
+            return msg;
+        })));
+    }
+    // Transform and enrich messages with extracted text
+    processedMessages = processedMessages.map(msg => {
+        // Transform to structured message format
+        const transformed = transformToSlackMessage(msg);
+        // Extract readable text from blocks/attachments
+        const extractedText = extractMessageText(transformed);
+        if (extractedText) {
+            msg.extractedText = extractedText;
+        }
+        // Simplify files first (to extract highest quality thumb before removing thumb fields)
+        if (msg.files && Array.isArray(msg.files)) {
+            msg.files = msg.files.map(file => simplifyFile(file));
+        }
+        // Simplify reactions (remove users array, keep just name and count)
+        if (msg.reactions && Array.isArray(msg.reactions)) {
+            msg.reactions = msg.reactions.map((reaction) => ({
+                name: reaction.name,
+                count: reaction.count,
+            }));
+        }
+        // Process root field for thread_broadcast messages
+        if (msg.root && typeof msg.root === "object") {
+            const root = msg.root;
+            // Simplify files in root
+            if (root.files && Array.isArray(root.files)) {
+                root.files = root.files.map((file) => simplifyFile(file));
+            }
+            // Simplify reactions in root
+            if (root.reactions && Array.isArray(root.reactions)) {
+                root.reactions = root.reactions.map((reaction) => ({
+                    name: reaction.name,
+                    count: reaction.count,
+                }));
+            }
+            // Remove redundant fields from root
+            removeRedundantFields(root);
+        }
+        // Remove all redundant fields recursively from the entire message
+        // Note: replies are already processed when fetched if includeThreadReplies is true
+        removeRedundantFields(msg);
+        return msg;
+    });
     return {
-        messages: messages.messages,
+        messages: processedMessages,
+        hasMore: messages.has_more,
+        nextCursor: (_b = messages.response_metadata) === null || _b === void 0 ? void 0 : _b.next_cursor,
     };
 });
 export default getChannelMessages;

package/dist/actions/providers/slack/messageTransformers.d.ts

@@ -0,0 +1,53 @@
+import type { KnownBlock } from "@slack/web-api";
+import type { Attachment } from "@slack/web-api/dist/types/response/ChannelsHistoryResponse.js";
+import type { MessageElement } from "@slack/web-api/dist/types/response/ConversationsHistoryResponse.js";
+export interface SlackMessage {
+    ts?: string;
+    text?: string;
+    user?: string;
+    username?: string;
+    thread_ts?: string;
+    blocks?: KnownBlock[];
+    attachments?: Attachment[];
+    reactions?: Array<{
+        name: string;
+        count: number;
+        users: string[];
+    }>;
+    files?: Array<{
+        name?: string;
+        title?: string;
+        mimetype?: string;
+        url_private?: string;
+    }>;
+}
+export type SimplifiedFile = {
+    id: string;
+    created?: number;
+    timestamp?: number;
+    name?: string;
+    title?: string;
+    mimetype?: string;
+    file_access?: string;
+    highest_thumb?: string;
+};
+/**
+ * Get the highest quality thumbnail from a file
+ */
+export declare function getHighestQualityThumb(file: Record<string, unknown>): string | undefined;
+/**
+ * Simplify file objects to only include essential fields and highest quality thumbnail
+ */
+export declare function simplifyFile(file: Record<string, unknown>): SimplifiedFile;
+/**
+ * Recursively remove redundant fields from an object to reduce payload size
+ */
+export declare function removeRedundantFields(obj: Record<string, unknown>): void;
+/**
+ * Extracts all visible text from a Slack message
+ */
+export declare function extractMessageText(m: SlackMessage | undefined): string | undefined;
+/**
+ * Transforms a Slack MessageElement to a simplified SlackMessage
+ */
+export declare function transformToSlackMessage(message: MessageElement): SlackMessage;

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/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,29 +19,5 @@ export interface SlackSearchMessage {
         userName?: string;
     }>;
 }
-interface SlackMessage {
-    ts?: string;
-    text?: string;
-    user?: string;
-    username?: string;
-    thread_ts?: string;
-    blocks?: KnownBlock[];
-    attachments?: Attachment[];
-    reactions?: Array<{
-        name: string;
-        count: number;
-        users: string[];
-    }>;
-    files?: Array<{
-        name?: string;
-        title?: string;
-        mimetype?: string;
-        url_private?: string;
-    }>;
-}
-/**
- * Extracts all visible text from a Slack message
- */
-export declare function extractMessageText(m: SlackMessage | undefined): string | undefined;
 declare const searchSlack: slackUserSearchSlackFunction;
 export default searchSlack;