@agentforge/tools 0.8.2 → 0.9.1

package/dist/index.js

@@ -2,6 +2,7 @@ import { toolBuilder, ToolCategory, LogLevel, createLogger } from '@agentforge/c
 import { z } from 'zod';
 import axios from 'axios';
 import * as cheerio2 from 'cheerio';
+import { WebClient } from '@slack/web-api';
 import { parse } from 'csv-parse/sync';
 import { stringify } from 'csv-stringify/sync';
 import { XMLParser, XMLBuilder } from 'fast-xml-parser';
@@ -656,6 +657,381 @@ var webSearch = toolBuilder().name("web-search").description(
     };
   }
 }).build();
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
+var logger = createLogger("tools:slack", { level: logLevel });
+var defaultSlackClient = null;
+function getDefaultSlackClient() {
+  if (!defaultSlackClient) {
+    const token = process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN;
+    if (!token) {
+      throw new Error(
+        "Slack token not configured. Please set SLACK_USER_TOKEN or SLACK_BOT_TOKEN environment variable."
+      );
+    }
+    defaultSlackClient = new WebClient(token);
+  }
+  return defaultSlackClient;
+}
+var sendSlackMessage = toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
+  "Use this for general team communication. For notifications with @mentions, consider using notify-slack instead. Use get-slack-channels first if you need to find the right channel."
+).suggests(["get-slack-channels"]).schema(
+  z.object({
+    channel: z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
+    message: z.string().describe("Message content to send")
+  })
+).implementSafe(async ({ channel, message }) => {
+  logger.info("send-slack-message called", { channel, messageLength: message.length });
+  try {
+    const slack = getDefaultSlackClient();
+    const result = await slack.chat.postMessage({
+      channel,
+      text: message,
+      username: "AgentForge Bot",
+      icon_emoji: ":robot_face:"
+    });
+    logger.info("send-slack-message result", {
+      channel: result.channel,
+      timestamp: result.ts,
+      messageLength: message.length,
+      success: true
+    });
+    return {
+      channel: result.channel,
+      message,
+      timestamp: result.ts,
+      message_id: result.ts
+    };
+  } catch (error) {
+    logger.error("send-slack-message failed", {
+      channel,
+      error: error.message,
+      data: error.data
+    });
+    throw error;
+  }
+}).build();
+var notifySlack = toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
+  "Use this for urgent notifications that require @mentions. For general messages without mentions, use send-slack-message instead."
+).suggests(["get-slack-channels"]).schema(
+  z.object({
+    channel: z.string().describe("Channel name or ID"),
+    message: z.string().describe("Notification message"),
+    mentions: z.array(z.string()).optional().describe("List of usernames to mention (without @)")
+  })
+).implementSafe(async ({ channel, message, mentions = [] }) => {
+  logger.info("notify-slack called", {
+    channel,
+    messageLength: message.length,
+    mentionCount: mentions.length
+  });
+  const slack = getDefaultSlackClient();
+  const mentionText = mentions.length > 0 ? mentions.map((m) => `<@${m}>`).join(" ") + " " : "";
+  const fullMessage = `${mentionText}${message}`;
+  const result = await slack.chat.postMessage({
+    channel,
+    text: fullMessage,
+    username: "AgentForge Bot",
+    icon_emoji: ":robot_face:"
+  });
+  logger.info("notify-slack result", {
+    channel: result.channel,
+    timestamp: result.ts,
+    mentions: mentions.length
+  });
+  return {
+    channel: result.channel,
+    message: fullMessage,
+    mentions,
+    timestamp: result.ts,
+    notification_id: result.ts
+  };
+}).build();
+var getSlackChannels = toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
+  "Use this first to discover available channels before sending messages. Helps ensure you are sending to the correct channel."
+).follows(["send-slack-message", "notify-slack"]).schema(
+  z.object({
+    include_private: z.boolean().optional().describe("Include private channels (default: false)")
+  })
+).implementSafe(async ({ include_private = false }) => {
+  logger.info("get-slack-channels called", { include_private });
+  const slack = getDefaultSlackClient();
+  const publicChannels = await slack.conversations.list({
+    types: "public_channel",
+    exclude_archived: true
+  });
+  let allChannels = publicChannels.channels || [];
+  if (include_private) {
+    const privateChannels = await slack.conversations.list({
+      types: "private_channel",
+      exclude_archived: true
+    });
+    allChannels = [...allChannels, ...privateChannels.channels || []];
+  }
+  logger.info("get-slack-channels result", {
+    channelCount: allChannels.length,
+    includePrivate: include_private
+  });
+  return {
+    count: allChannels.length,
+    channels: allChannels.map((c) => ({
+      id: c.id,
+      name: c.name,
+      is_private: c.is_private || false,
+      num_members: c.num_members || 0
+    }))
+  };
+}).build();
+var getSlackMessages = toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
+  "Use this to read recent messages from a channel. Use get-slack-channels first if you need to find the channel ID. Returns messages in reverse chronological order (newest first)."
+).suggests(["get-slack-channels"]).schema(
+  z.object({
+    channel: z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
+    limit: z.number().int().min(1).max(100).optional().describe("Number of messages to retrieve (default: 20, max: 100)")
+  })
+).implementSafe(async ({ channel, limit = 20 }) => {
+  logger.info("get-slack-messages called", { channel, limit });
+  try {
+    const slack = getDefaultSlackClient();
+    let channelId = channel;
+    if (!channel.startsWith("C") && !channel.startsWith("D")) {
+      const channels = await slack.conversations.list({
+        types: "public_channel,private_channel",
+        exclude_archived: true
+      });
+      const found = channels.channels?.find((c) => c.name === channel);
+      if (!found) {
+        logger.error("get-slack-messages: channel not found", { channel });
+        throw new Error(
+          `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
+        );
+      }
+      channelId = found.id;
+    }
+    const result = await slack.conversations.history({
+      channel: channelId,
+      limit: Math.min(limit, 100)
+      // Cap at 100 for performance
+    });
+    logger.info("get-slack-messages result", {
+      channel: channelId,
+      messageCount: result.messages?.length || 0,
+      limit
+    });
+    return {
+      channel: channelId,
+      count: result.messages?.length || 0,
+      messages: result.messages?.map((m) => ({
+        user: m.user || "unknown",
+        text: m.text || "",
+        timestamp: m.ts,
+        thread_ts: m.thread_ts,
+        type: m.type,
+        subtype: m.subtype
+      })) || []
+    };
+  } catch (error) {
+    logger.error("get-slack-messages failed", {
+      channel,
+      error: error.message,
+      data: error.data
+    });
+    throw error;
+  }
+}).build();
+function createSlackTools(config = {}) {
+  const {
+    token,
+    botName = "AgentForge Bot",
+    botIcon = ":robot_face:",
+    logLevel: customLogLevel
+  } = config;
+  let configuredClient = null;
+  function getConfiguredSlackClient() {
+    if (!configuredClient) {
+      const slackToken = token || process.env.SLACK_USER_TOKEN || process.env.SLACK_BOT_TOKEN;
+      if (!slackToken) {
+        throw new Error(
+          "Slack token not configured. Please provide a token in config or set SLACK_USER_TOKEN or SLACK_BOT_TOKEN environment variable."
+        );
+      }
+      configuredClient = new WebClient(slackToken);
+    }
+    return configuredClient;
+  }
+  const toolLogger = customLogLevel ? createLogger("tools:slack", { level: customLogLevel }) : logger;
+  const sendMessage = toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
+    "Use this for general team communication. For notifications with @mentions, consider using notify-slack instead. Use get-slack-channels first if you need to find the right channel."
+  ).suggests(["get-slack-channels"]).schema(
+    z.object({
+      channel: z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
+      message: z.string().describe("Message content to send")
+    })
+  ).implementSafe(async ({ channel, message }) => {
+    toolLogger.info("send-slack-message called", { channel, messageLength: message.length });
+    try {
+      const slack = getConfiguredSlackClient();
+      const result = await slack.chat.postMessage({
+        channel,
+        text: message,
+        username: botName,
+        icon_emoji: botIcon
+      });
+      toolLogger.info("send-slack-message result", {
+        channel: result.channel,
+        timestamp: result.ts,
+        messageLength: message.length,
+        success: true
+      });
+      return {
+        channel: result.channel,
+        message,
+        timestamp: result.ts,
+        message_id: result.ts
+      };
+    } catch (error) {
+      toolLogger.error("send-slack-message failed", {
+        channel,
+        error: error.message,
+        data: error.data
+      });
+      throw error;
+    }
+  }).build();
+  const notify = toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
+    "Use this for urgent notifications that require @mentions. For general messages without mentions, use send-slack-message instead."
+  ).suggests(["get-slack-channels"]).schema(
+    z.object({
+      channel: z.string().describe("Channel name or ID"),
+      message: z.string().describe("Notification message"),
+      mentions: z.array(z.string()).optional().describe("List of usernames to mention (without @)")
+    })
+  ).implementSafe(async ({ channel, message, mentions = [] }) => {
+    toolLogger.info("notify-slack called", {
+      channel,
+      messageLength: message.length,
+      mentionCount: mentions.length
+    });
+    const slack = getConfiguredSlackClient();
+    const mentionText = mentions.length > 0 ? mentions.map((m) => `<@${m}>`).join(" ") + " " : "";
+    const fullMessage = `${mentionText}${message}`;
+    const result = await slack.chat.postMessage({
+      channel,
+      text: fullMessage,
+      username: botName,
+      icon_emoji: botIcon
+    });
+    toolLogger.info("notify-slack result", {
+      channel: result.channel,
+      timestamp: result.ts,
+      mentions: mentions.length
+    });
+    return {
+      channel: result.channel,
+      message: fullMessage,
+      mentions,
+      timestamp: result.ts,
+      notification_id: result.ts
+    };
+  }).build();
+  const getChannels = toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
+    "Use this first to discover available channels before sending messages. Helps ensure you are sending to the correct channel."
+  ).follows(["send-slack-message", "notify-slack"]).schema(
+    z.object({
+      include_private: z.boolean().optional().describe("Include private channels (default: false)")
+    })
+  ).implementSafe(async ({ include_private = false }) => {
+    toolLogger.info("get-slack-channels called", { include_private });
+    const slack = getConfiguredSlackClient();
+    const publicChannels = await slack.conversations.list({
+      types: "public_channel",
+      exclude_archived: true
+    });
+    let allChannels = publicChannels.channels || [];
+    if (include_private) {
+      const privateChannels = await slack.conversations.list({
+        types: "private_channel",
+        exclude_archived: true
+      });
+      allChannels = [...allChannels, ...privateChannels.channels || []];
+    }
+    toolLogger.info("get-slack-channels result", {
+      channelCount: allChannels.length,
+      includePrivate: include_private
+    });
+    return {
+      count: allChannels.length,
+      channels: allChannels.map((c) => ({
+        id: c.id,
+        name: c.name,
+        is_private: c.is_private || false,
+        num_members: c.num_members || 0
+      }))
+    };
+  }).build();
+  const getMessages = toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
+    "Use this to read recent messages from a channel. Use get-slack-channels first if you need to find the channel ID. Returns messages in reverse chronological order (newest first)."
+  ).suggests(["get-slack-channels"]).schema(
+    z.object({
+      channel: z.string().describe("Channel name (e.g., 'general') or ID (e.g., 'C123456')"),
+      limit: z.number().int().min(1).max(100).optional().describe("Number of messages to retrieve (default: 20, max: 100)")
+    })
+  ).implementSafe(async ({ channel, limit = 20 }) => {
+    toolLogger.info("get-slack-messages called", { channel, limit });
+    try {
+      const slack = getConfiguredSlackClient();
+      let channelId = channel;
+      if (!channel.startsWith("C") && !channel.startsWith("D")) {
+        const channels = await slack.conversations.list({
+          types: "public_channel,private_channel",
+          exclude_archived: true
+        });
+        const found = channels.channels?.find((c) => c.name === channel);
+        if (!found) {
+          toolLogger.error("get-slack-messages: channel not found", { channel });
+          throw new Error(
+            `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
+          );
+        }
+        channelId = found.id;
+      }
+      const result = await slack.conversations.history({
+        channel: channelId,
+        limit: Math.min(limit, 100)
+      });
+      toolLogger.info("get-slack-messages result", {
+        channel: channelId,
+        messageCount: result.messages?.length || 0,
+        limit
+      });
+      return {
+        channel: channelId,
+        count: result.messages?.length || 0,
+        messages: result.messages?.map((m) => ({
+          user: m.user || "unknown",
+          text: m.text || "",
+          timestamp: m.ts,
+          thread_ts: m.thread_ts,
+          type: m.type,
+          subtype: m.subtype
+        })) || []
+      };
+    } catch (error) {
+      toolLogger.error("get-slack-messages failed", {
+        channel,
+        error: error.message,
+        data: error.data
+      });
+      throw error;
+    }
+  }).build();
+  return {
+    sendMessage,
+    notify,
+    getChannels,
+    getMessages
+  };
+}
+var slackTools = [sendSlackMessage, notifySlack, getSlackChannels, getSlackMessages];
 var jsonParser = toolBuilder().name("json-parser").description("Parse JSON string into an object. Validates JSON syntax and returns parsed data or error details.").category(ToolCategory.UTILITY).tags(["json", "parse", "data"]).schema(z.object({
   json: z.string().describe("JSON string to parse"),
   strict: z.boolean().default(true).describe("Use strict JSON parsing (no trailing commas, etc.)")
@@ -1880,8 +2256,8 @@ var AskHumanInputSchema = z.object({
    */
   suggestions: z.array(z.string()).optional().describe("Suggested responses for the human")
 });
-var logLevel = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
-var logger = createLogger("askHuman", { level: logLevel });
+var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
+var logger2 = createLogger("askHuman", { level: logLevel2 });
 function createAskHumanTool() {
   return toolBuilder().name("ask-human").description(
     "Ask a human for input or approval. Use this when you need human guidance, approval for a critical action, or clarification on ambiguous requirements. The agent execution will pause until the human responds."
@@ -1914,13 +2290,13 @@ function createAskHumanTool() {
       suggestions: validatedInput.suggestions,
       status: "pending"
     };
-    logger.debug("About to call interrupt()", { humanRequest });
+    logger2.debug("About to call interrupt()", { humanRequest });
     let response;
     try {
       response = interrupt(humanRequest);
-      logger.debug("interrupt() returned successfully", { response, responseType: typeof response });
+      logger2.debug("interrupt() returned successfully", { response, responseType: typeof response });
     } catch (error) {
-      logger.debug("interrupt() threw error (expected for GraphInterrupt)", {
+      logger2.debug("interrupt() threw error (expected for GraphInterrupt)", {
         errorType: error?.constructor?.name,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -1945,6 +2321,6 @@ function createAskHumanTool() {
 }
 var askHumanTool = createAskHumanTool();
 
-export { AskHumanInputSchema, DuckDuckGoProvider, SerperProvider, arrayFilter, arrayGroupBy, arrayMap, arraySort, askHumanTool, calculator, createAskHumanTool, createDuckDuckGoProvider, createSerperProvider, creditCardValidator, csvGenerator, csvParser, csvToJson, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, directoryCreate, directoryDelete, directoryList, emailValidator, extractImages, extractLinks, fileAppend, fileDelete, fileExists, fileReader, fileSearch, fileWriter, htmlParser, httpClient, httpGet, httpPost, ipValidator, jsonMerge, jsonParser, jsonQuery, jsonStringify, jsonToCsv, jsonToXml, jsonValidator, mathFunctions, objectOmit, objectPick, pathBasename, pathDirname, pathExtension, pathJoin, pathNormalize, pathParse, pathRelative, pathResolve, phoneValidator, randomNumber, searchResultSchema, statistics, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, urlBuilder, urlQueryParser, urlValidator, urlValidatorSimple, uuidValidator, webScraper, webSearch, webSearchOutputSchema, webSearchSchema, xmlGenerator, xmlParser, xmlToJson };
+export { AskHumanInputSchema, DuckDuckGoProvider, SerperProvider, arrayFilter, arrayGroupBy, arrayMap, arraySort, askHumanTool, calculator, createAskHumanTool, createDuckDuckGoProvider, createSerperProvider, createSlackTools, creditCardValidator, csvGenerator, csvParser, csvToJson, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, directoryCreate, directoryDelete, directoryList, emailValidator, extractImages, extractLinks, fileAppend, fileDelete, fileExists, fileReader, fileSearch, fileWriter, getSlackChannels, getSlackMessages, htmlParser, httpClient, httpGet, httpPost, ipValidator, jsonMerge, jsonParser, jsonQuery, jsonStringify, jsonToCsv, jsonToXml, jsonValidator, mathFunctions, notifySlack, objectOmit, objectPick, pathBasename, pathDirname, pathExtension, pathJoin, pathNormalize, pathParse, pathRelative, pathResolve, phoneValidator, randomNumber, searchResultSchema, sendSlackMessage, slackTools, statistics, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, urlBuilder, urlQueryParser, urlValidator, urlValidatorSimple, uuidValidator, webScraper, webSearch, webSearchOutputSchema, webSearchSchema, xmlGenerator, xmlParser, xmlToJson };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map