reddit-mcp-server 1.0.6 → 1.0.7

package/src/tools/__tests__/search-tools.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { searchReddit } from "../search-tools"
-import { getRedditClient } from "../../client/reddit-client"
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
-
-vi.mock("../../client/reddit-client")
-
-describe("searchReddit", () => {
-  const mockRedditClient = {
-    searchReddit: vi.fn(),
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(getRedditClient).mockReturnValue(mockRedditClient as any)
-  })
-
-  it("should search Reddit with default parameters", async () => {
-    const mockPosts = [
-      {
-        id: "test1",
-        title: "Test Post 1",
-        author: "testuser1",
-        subreddit: "testsubreddit",
-        score: 100,
-        upvoteRatio: 0.95,
-        numComments: 10,
-        createdUtc: 1700000000,
-        selftext: "This is a test post",
-        permalink: "/r/testsubreddit/comments/test1",
-        over18: false,
-        spoiler: false,
-      },
-    ]
-
-    mockRedditClient.searchReddit.mockResolvedValue(mockPosts)
-
-    const result = await searchReddit({ query: "test query" })
-
-    expect(mockRedditClient.searchReddit).toHaveBeenCalledWith("test query", {
-      subreddit: undefined,
-      sort: "relevance",
-      timeFilter: "all",
-      limit: 10,
-      type: "link",
-    })
-
-    expect(result.content).toHaveLength(1)
-    expect(result.content[0].type).toBe("text")
-    expect(result.content[0].text).toContain('Reddit Search Results for: "test query"')
-    expect(result.content[0].text).toContain("Test Post 1")
-  })
-
-  it("should search within a specific subreddit", async () => {
-    mockRedditClient.searchReddit.mockResolvedValue([])
-
-    await searchReddit({
-      query: "test",
-      subreddit: "programming",
-      sort: "top",
-      time_filter: "week",
-      limit: 5,
-      type: "link",
-    })
-
-    expect(mockRedditClient.searchReddit).toHaveBeenCalledWith("test", {
-      subreddit: "programming",
-      sort: "top",
-      timeFilter: "week",
-      limit: 5,
-      type: "link",
-    })
-  })
-
-  it("should throw error if Reddit client is not initialized", async () => {
-    vi.mocked(getRedditClient).mockReturnValue(null)
-
-    await expect(searchReddit({ query: "test" })).rejects.toThrow(
-      new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
-    )
-  })
-
-  it("should throw error if query is empty", async () => {
-    await expect(searchReddit({ query: "" })).rejects.toThrow(
-      new McpError(ErrorCode.InvalidParams, "Search query cannot be empty"),
-    )
-
-    await expect(searchReddit({ query: "   " })).rejects.toThrow(
-      new McpError(ErrorCode.InvalidParams, "Search query cannot be empty"),
-    )
-  })
-
-  it("should handle search errors", async () => {
-    mockRedditClient.searchReddit.mockRejectedValue(new Error("API Error"))
-
-    await expect(searchReddit({ query: "test" })).rejects.toThrow(
-      new McpError(ErrorCode.InternalError, "Failed to search Reddit: Error: API Error"),
-    )
-  })
-})

package/src/tools/__tests__/user-tools.test.ts

@@ -1,258 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { getUserInfo, getUserPosts, getUserComments } from "../user-tools"
-import { getRedditClient } from "../../client/reddit-client"
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
-
-vi.mock("../../client/reddit-client")
-
-describe("user-tools", () => {
-  const mockRedditClient = {
-    getUser: vi.fn(),
-    getUserPosts: vi.fn(),
-    getUserComments: vi.fn(),
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(getRedditClient).mockReturnValue(mockRedditClient as any)
-  })
-
-  describe("getUserInfo", () => {
-    it("should fetch and format user information", async () => {
-      const mockUser = {
-        name: "testuser",
-        id: "user123",
-        commentKarma: 5000,
-        linkKarma: 1000,
-        totalKarma: 6000,
-        isMod: true,
-        isGold: false,
-        isEmployee: false,
-        createdUtc: 1600000000,
-        profileUrl: "https://reddit.com/user/testuser",
-      }
-
-      mockRedditClient.getUser.mockResolvedValue(mockUser)
-
-      const result = await getUserInfo({ username: "testuser" })
-
-      expect(mockRedditClient.getUser).toHaveBeenCalledWith("testuser")
-      expect(result.content).toHaveLength(1)
-      expect(result.content[0].type).toBe("text")
-      expect(result.content[0].text).toContain("User Information: u/testuser")
-      expect(result.content[0].text).toContain("Comment Karma: 5,000")
-      expect(result.content[0].text).toContain("Moderator")
-    })
-
-    it("should throw error if Reddit client is not initialized", async () => {
-      vi.mocked(getRedditClient).mockReturnValue(null)
-
-      await expect(getUserInfo({ username: "test" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
-      )
-    })
-
-    it("should handle API errors", async () => {
-      mockRedditClient.getUser.mockRejectedValue(new Error("User not found"))
-
-      await expect(getUserInfo({ username: "nonexistent" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Failed to fetch user data: Error: User not found"),
-      )
-    })
-  })
-
-  describe("getUserPosts", () => {
-    it("should fetch user posts with default parameters", async () => {
-      const mockPosts = [
-        {
-          id: "post1",
-          title: "My First Post",
-          author: "testuser",
-          subreddit: "programming",
-          score: 100,
-          upvoteRatio: 0.95,
-          numComments: 20,
-          createdUtc: 1700000000,
-          selftext: "This is my post content",
-          permalink: "/r/programming/comments/post1",
-          over18: false,
-          spoiler: false,
-        },
-      ]
-
-      mockRedditClient.getUserPosts.mockResolvedValue(mockPosts)
-
-      const result = await getUserPosts({ username: "testuser" })
-
-      expect(mockRedditClient.getUserPosts).toHaveBeenCalledWith("testuser", {
-        sort: "new",
-        timeFilter: "all",
-        limit: 10,
-      })
-
-      expect(result.content).toHaveLength(1)
-      expect(result.content[0].type).toBe("text")
-      expect(result.content[0].text).toContain("Posts by u/testuser")
-      expect(result.content[0].text).toContain("My First Post")
-      expect(result.content[0].text).toContain("Subreddit: r/programming")
-    })
-
-    it("should fetch posts with custom parameters", async () => {
-      mockRedditClient.getUserPosts.mockResolvedValue([])
-
-      await getUserPosts({
-        username: "testuser",
-        sort: "top",
-        time_filter: "week",
-        limit: 25,
-      })
-
-      expect(mockRedditClient.getUserPosts).toHaveBeenCalledWith("testuser", {
-        sort: "top",
-        timeFilter: "week",
-        limit: 25,
-      })
-    })
-
-    it("should handle NSFW and spoiler posts", async () => {
-      const mockPosts = [
-        {
-          id: "post2",
-          title: "NSFW Post",
-          author: "testuser",
-          subreddit: "test",
-          score: 50,
-          upvoteRatio: 0.8,
-          numComments: 5,
-          createdUtc: 1700000000,
-          selftext: "",
-          permalink: "/r/test/comments/post2",
-          over18: true,
-          spoiler: true,
-        },
-      ]
-
-      mockRedditClient.getUserPosts.mockResolvedValue(mockPosts)
-
-      const result = await getUserPosts({ username: "testuser" })
-
-      expect(result.content[0].text).toContain("**NSFW**")
-      expect(result.content[0].text).toContain("**Spoiler**")
-    })
-
-    it("should throw error if Reddit client is not initialized", async () => {
-      vi.mocked(getRedditClient).mockReturnValue(null)
-
-      await expect(getUserPosts({ username: "test" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
-      )
-    })
-
-    it("should handle API errors", async () => {
-      mockRedditClient.getUserPosts.mockRejectedValue(new Error("API Error"))
-
-      await expect(getUserPosts({ username: "test" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Failed to fetch user posts: Error: API Error"),
-      )
-    })
-  })
-
-  describe("getUserComments", () => {
-    it("should fetch user comments with default parameters", async () => {
-      const mockComments = [
-        {
-          id: "comment1",
-          author: "testuser",
-          body: "This is my insightful comment",
-          score: 42,
-          subreddit: "programming",
-          submissionTitle: "Cool Programming Topic",
-          createdUtc: 1700000000,
-          edited: false,
-          isSubmitter: false,
-          permalink: "/r/programming/comments/xyz/cool_programming_topic/comment1",
-        },
-      ]
-
-      mockRedditClient.getUserComments.mockResolvedValue(mockComments)
-
-      const result = await getUserComments({ username: "testuser" })
-
-      expect(mockRedditClient.getUserComments).toHaveBeenCalledWith("testuser", {
-        sort: "new",
-        timeFilter: "all",
-        limit: 10,
-      })
-
-      expect(result.content).toHaveLength(1)
-      expect(result.content[0].type).toBe("text")
-      expect(result.content[0].text).toContain("Comments by u/testuser")
-      expect(result.content[0].text).toContain('In r/programming on "Cool Programming Topic"')
-      expect(result.content[0].text).toContain("This is my insightful comment")
-    })
-
-    it("should handle edited comments", async () => {
-      const mockComments = [
-        {
-          id: "comment2",
-          author: "testuser",
-          body: "Edited comment text",
-          score: 10,
-          subreddit: "test",
-          submissionTitle: "Test Post",
-          createdUtc: 1700000000,
-          edited: true,
-          isSubmitter: false,
-          permalink: "/r/test/comments/abc/test_post/comment2",
-        },
-      ]
-
-      mockRedditClient.getUserComments.mockResolvedValue(mockComments)
-
-      const result = await getUserComments({ username: "testuser" })
-
-      expect(result.content[0].text).toContain("*(edited)*")
-    })
-
-    it("should truncate long comments", async () => {
-      const longComment = "x".repeat(350)
-      const mockComments = [
-        {
-          id: "comment3",
-          author: "testuser",
-          body: longComment,
-          score: 5,
-          subreddit: "test",
-          submissionTitle: "Test",
-          createdUtc: 1700000000,
-          edited: false,
-          isSubmitter: false,
-          permalink: "/r/test/comments/def/test/comment3",
-        },
-      ]
-
-      mockRedditClient.getUserComments.mockResolvedValue(mockComments)
-
-      const result = await getUserComments({ username: "testuser" })
-
-      expect(result.content[0].text).toContain("x".repeat(300) + "...")
-      expect(result.content[0].text).not.toContain("x".repeat(301))
-    })
-
-    it("should throw error if Reddit client is not initialized", async () => {
-      vi.mocked(getRedditClient).mockReturnValue(null)
-
-      await expect(getUserComments({ username: "test" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
-      )
-    })
-
-    it("should handle API errors", async () => {
-      mockRedditClient.getUserComments.mockRejectedValue(new Error("API Error"))
-
-      await expect(getUserComments({ username: "test" })).rejects.toThrow(
-        new McpError(ErrorCode.InternalError, "Failed to fetch user comments: Error: API Error"),
-      )
-    })
-  })
-})

package/src/tools/comment-tools.ts

@@ -1,61 +0,0 @@
-import { getRedditClient } from "../client/reddit-client"
-import { formatPost } from "../utils/formatters"
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
-
-export async function getPostComments(params: { post_id: string; subreddit: string; sort?: string; limit?: number }) {
-  const { post_id, subreddit, sort = "best", limit = 100 } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  if (!post_id || !subreddit) {
-    throw new McpError(ErrorCode.InvalidParams, "post_id and subreddit are required")
-  }
-
-  try {
-    const { post, comments } = await client.getPostComments(post_id, subreddit, {
-      sort,
-      limit,
-    })
-
-    const formattedPost = formatPost(post)
-
-    // Function to format comments with proper indentation
-    const formatComment = (comment: any): string => {
-      const edited = comment.edited ? " *(edited)*" : ""
-      const submitter = comment.isSubmitter ? " **[OP]**" : ""
-      const depth = comment.depth || 0
-      const prefix = "  ".repeat(depth) + (depth > 0 ? "└─ " : "")
-
-      return `${prefix}**u/${comment.author}**${submitter} • ${comment.score} points • ${new Date(comment.createdUtc * 1000).toLocaleString()}${edited}
-${prefix}${comment.body.split("\n").join(`\n${prefix}`)}`
-    }
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Comments for: ${formattedPost.title}
-
-## Post Details
-- Author: u/${formattedPost.author}
-- Subreddit: r/${formattedPost.subreddit}
-- Score: ${formattedPost.score} (${formattedPost.upvoteRatio}% upvoted)
-- Posted: ${formattedPost.createdAt}
-- Link: https://reddit.com${formattedPost.permalink}
-
-## Post Content
-${formattedPost.selftext || "[Link post - no text content]"}
-
-## Comments (${comments.length} loaded, sorted by ${sort})
-
-${comments.map((comment) => formatComment(comment)).join("\n\n---\n\n")}`,
-        },
-      ],
-    }
-  } catch (error) {
-    throw new McpError(ErrorCode.InternalError, `Failed to fetch comments: ${String(error)}`)
-  }
-}

package/src/tools/index.ts

@@ -1,5 +0,0 @@
-export * from "./user-tools"
-export * from "./post-tools"
-export * from "./subreddit-tools"
-export * from "./search-tools"
-export * from "./comment-tools"

package/src/tools/post-tools.ts

@@ -1,178 +0,0 @@
-import { getRedditClient } from "../client/reddit-client"
-import { formatPostInfo, formatCommentInfo } from "../utils/formatters"
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
-
-export async function getRedditPost(params: { subreddit: string; post_id: string }) {
-  const { subreddit, post_id } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  try {
-    // Getting post
-    const post = await client.getPost(post_id, subreddit)
-    const formattedPost = formatPostInfo(post)
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post from r/${formattedPost.subreddit}
-
-## Post Details
-- Title: ${formattedPost.title}
-- Type: ${formattedPost.type}
-- Author: u/${formattedPost.author}
-
-## Content
-${formattedPost.content}
-
-## Stats
-- Score: ${formattedPost.stats.score.toLocaleString()}
-- Upvote Ratio: ${(formattedPost.stats.upvoteRatio * 100).toFixed(1)}%
-- Comments: ${formattedPost.stats.comments.toLocaleString()}
-
-## Metadata
-- Posted: ${formattedPost.metadata.posted}
-- Flags: ${formattedPost.metadata.flags.length ? formattedPost.metadata.flags.join(", ") : "None"}
-- Flair: ${formattedPost.metadata.flair}
-
-## Links
-- Full Post: ${formattedPost.links.fullPost}
-- Short Link: ${formattedPost.links.shortLink}
-
-## Engagement Analysis
-- ${formattedPost.engagementAnalysis.replace(/\n  - /g, "\n- ")}
-
-## Best Time to Engage
-${formattedPost.bestTimeToEngage}
-          `,
-        },
-      ],
-    }
-  } catch (error) {
-    // Error will be logged by the server
-    throw new McpError(ErrorCode.InternalError, `Failed to fetch post data: ${String(error)}`)
-  }
-}
-
-export async function getTopPosts(params: { subreddit: string; time_filter?: string; limit?: number }) {
-  const { subreddit, time_filter = "week", limit = 10 } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  try {
-    // Getting top posts
-    const posts = await client.getTopPosts(subreddit, time_filter, limit)
-    const formattedPosts = posts.map(formatPostInfo)
-
-    const postSummaries = formattedPosts
-      .map(
-        (post, index) => `
-### ${index + 1}. ${post.title}
-- Author: u/${post.author}
-- Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
-- Comments: ${post.stats.comments.toLocaleString()}
-- Posted: ${post.metadata.posted}
-- Link: ${post.links.shortLink}
-    `,
-      )
-      .join("\n")
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Top Posts from r/${subreddit} (${time_filter})
-
-${postSummaries}
-          `,
-        },
-      ],
-    }
-  } catch (error) {
-    // Error will be logged by the server
-    throw new McpError(ErrorCode.InternalError, `Failed to fetch top posts: ${String(error)}`)
-  }
-}
-
-export async function createPost(params: { subreddit: string; title: string; content: string; is_self?: boolean }) {
-  const { subreddit, title, content, is_self = true } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  try {
-    // Creating post
-    const post = await client.createPost(subreddit, title, content, is_self)
-    const formattedPost = formatPostInfo(post)
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post Created Successfully
-
-## Post Details
-- Title: ${formattedPost.title}
-- Subreddit: r/${formattedPost.subreddit}
-- Type: ${formattedPost.type}
-- Link: ${formattedPost.links.fullPost}
-
-Your post has been successfully submitted to r/${formattedPost.subreddit}.
-          `,
-        },
-      ],
-    }
-  } catch (error) {
-    // Error will be logged by the server
-    throw new McpError(ErrorCode.InternalError, `Failed to create post: ${String(error)}`)
-  }
-}
-
-export async function replyToPost(params: { post_id: string; content: string; subreddit?: string }) {
-  const { post_id, content } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  try {
-    // Replying to post
-    const comment = await client.replyToPost(post_id, content)
-    const formattedComment = formatCommentInfo(comment)
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Reply Posted Successfully
-
-## Comment Details
-- Author: u/${formattedComment.author}
-- Subreddit: r/${formattedComment.context.subreddit}
-- Thread: ${formattedComment.context.thread}
-- Link: ${formattedComment.link}
-
-Your reply has been successfully posted.
-          `,
-        },
-      ],
-    }
-  } catch (error) {
-    // Error will be logged by the server
-    throw new McpError(ErrorCode.InternalError, `Failed to reply to post: ${String(error)}`)
-  }
-}

package/src/tools/search-tools.ts

@@ -1,67 +0,0 @@
-import { getRedditClient } from "../client/reddit-client"
-import { formatPost } from "../utils/formatters"
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
-
-export async function searchReddit(params: {
-  query: string
-  subreddit?: string
-  sort?: string
-  time_filter?: string
-  limit?: number
-  type?: string
-}) {
-  const { query, subreddit, sort = "relevance", time_filter = "all", limit = 10, type = "link" } = params
-  const client = getRedditClient()
-
-  if (!client) {
-    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
-  }
-
-  if (!query || query.trim().length === 0) {
-    throw new McpError(ErrorCode.InvalidParams, "Search query cannot be empty")
-  }
-
-  try {
-    const posts = await client.searchReddit(query, {
-      subreddit,
-      sort,
-      timeFilter: time_filter,
-      limit,
-      type,
-    })
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Reddit Search Results for: "${query}"${subreddit ? ` in r/${subreddit}` : ""}
-
-## Search Parameters
-- Sort: ${sort}
-- Time Filter: ${time_filter}
-- Type: ${type}
-- Results: ${posts.length}
-
-${posts
-  .map((post, index) => {
-    const formatted = formatPost(post)
-    return `### ${index + 1}. ${formatted.title}
-- Author: u/${formatted.author}
-- Subreddit: r/${formatted.subreddit}
-- Score: ${formatted.score} (${formatted.upvoteRatio}% upvoted)
-- Comments: ${formatted.numComments}
-- Posted: ${formatted.createdAt}
-${formatted.selftext ? `\n${formatted.selftext.substring(0, 200)}${formatted.selftext.length > 200 ? "..." : ""}\n` : ""}
-- Link: https://reddit.com${formatted.permalink}
-${formatted.nsfw ? "- **NSFW**" : ""}
-${formatted.spoiler ? "- **Spoiler**" : ""}
-`
-  })
-  .join("\n")}`,
-        },
-      ],
-    }
-  } catch (error) {
-    throw new McpError(ErrorCode.InternalError, `Failed to search Reddit: ${String(error)}`)
-  }
-}