reddit-mcp-server 1.0.4 → 1.0.6

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

@@ -0,0 +1,258 @@
+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

@@ -0,0 +1,61 @@
+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,3 +1,5 @@
 export * from "./user-tools"
 export * from "./post-tools"
 export * from "./subreddit-tools"
+export * from "./search-tools"
+export * from "./comment-tools"

package/src/tools/search-tools.ts

@@ -0,0 +1,67 @@
+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)}`)
+  }
+}

package/src/tools/user-tools.ts

@@ -46,3 +46,102 @@ export async function getUserInfo(params: { username: string }) {
     throw new McpError(ErrorCode.InternalError, `Failed to fetch user data: ${String(error)}`)
   }
 }
+
+export async function getUserPosts(params: { username: string; sort?: string; time_filter?: string; limit?: number }) {
+  const { username, sort = "new", time_filter = "all", limit = 10 } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    const posts = await client.getUserPosts(username, {
+      sort,
+      timeFilter: time_filter,
+      limit,
+    })
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Posts by u/${username}
+
+## Sort: ${sort} | Time: ${time_filter} | Count: ${posts.length}
+
+${posts
+  .map((post, index) => {
+    const date = new Date(post.createdUtc * 1000).toLocaleString()
+    const selftext = post.selftext
+      ? `\n${post.selftext.substring(0, 200)}${post.selftext.length > 200 ? "..." : ""}\n`
+      : ""
+
+    return `### ${index + 1}. ${post.title}
+- Subreddit: r/${post.subreddit}
+- Score: ${post.score} (${Math.round(post.upvoteRatio * 100)}% upvoted)
+- Comments: ${post.numComments}
+- Posted: ${date}
+${selftext}
+- Link: https://reddit.com${post.permalink}
+${post.over18 ? "- **NSFW**" : ""}
+${post.spoiler ? "- **Spoiler**" : ""}`
+  })
+  .join("\n\n---\n\n")}`,
+        },
+      ],
+    }
+  } catch (error) {
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch user posts: ${String(error)}`)
+  }
+}
+
+export async function getUserComments(params: {
+  username: string
+  sort?: string
+  time_filter?: string
+  limit?: number
+}) {
+  const { username, sort = "new", time_filter = "all", limit = 10 } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    const comments = await client.getUserComments(username, {
+      sort,
+      timeFilter: time_filter,
+      limit,
+    })
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Comments by u/${username}
+
+## Sort: ${sort} | Time: ${time_filter} | Count: ${comments.length}
+
+${comments
+  .map((comment, index) => {
+    const date = new Date(comment.createdUtc * 1000).toLocaleString()
+    const edited = comment.edited ? " *(edited)*" : ""
+    const body = comment.body.length > 300 ? comment.body.substring(0, 300) + "..." : comment.body
+
+    return `### ${index + 1}. In r/${comment.subreddit} on "${comment.submissionTitle}"
+- Score: ${comment.score} points
+- Posted: ${date}${edited}
+- Link: https://reddit.com${comment.permalink}
+
+${body}`
+  })
+  .join("\n\n---\n\n")}`,
+        },
+      ],
+    }
+  } catch (error) {
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch user comments: ${String(error)}`)
+  }
+}

package/src/types.ts

@@ -50,6 +50,8 @@ export interface RedditComment {
   edited: boolean
   isSubmitter: boolean
   permalink: string
+  depth?: number
+  parentId?: string
 }
 
 export interface RedditSubreddit {

package/src/utils/formatters.ts

@@ -297,3 +297,20 @@ export function formatCommentInfo(comment: RedditComment): FormattedCommentInfo
     commentAnalysis: analyzeCommentImpact(comment.score, comment.edited, comment.isSubmitter),
   }
 }
+
+// Simple formatter for posts (used in search and comment tools)
+export function formatPost(post: RedditPost) {
+  return {
+    title: post.title,
+    author: post.author,
+    subreddit: post.subreddit,
+    score: post.score,
+    upvoteRatio: Math.round(post.upvoteRatio * 100),
+    numComments: post.numComments,
+    createdAt: formatTimestamp(post.createdUtc),
+    selftext: post.selftext,
+    permalink: post.permalink,
+    nsfw: post.over18,
+    spoiler: post.spoiler,
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/mockData.ts',
+        '**/bin.ts',
+      ]
+    },
+  },
+})