feat: add fetchProblemSimplified method to LeetCode services and corresponding tests

Author: jinzcdev

src/leetcode/leetcode-base-service.ts

@@ -109,6 +109,15 @@ export interface LeetCodeBaseService {
      */
     fetchDailyChallenge(): Promise<any>;
 
+    /**
+     * Retrieves simplified information about a specific problem.
+     * Returns only the most useful fields for the user.
+     *
+     * @param titleSlug - Problem identifier/slug as used in the LeetCode URL
+     * @returns Promise resolving to the simplified problem details
+     */
+    fetchProblemSimplified(titleSlug: string): Promise<any>;
+
     /**
      * Retrieves detailed information about a specific problem.
      *

src/leetcode/leetcode-cn-service.ts

@@ -206,6 +206,57 @@ export class LeetCodeCNService implements LeetCodeBaseService {
         }
     }
 
+    async fetchProblemSimplified(titleSlug: string): Promise<any> {
+        try {
+            const problem = await this.fetchProblem(titleSlug);
+            if (!problem) {
+                throw new Error(`Problem ${titleSlug} not found`);
+            }
+
+            const filteredTopicTags =
+                problem.topicTags?.map((tag: any) => tag.slug) || [];
+
+            const filteredCodeSnippets =
+                problem.codeSnippets?.filter((snippet: any) =>
+                    ["cpp", "python3", "java"].includes(snippet.langSlug)
+                ) || [];
+
+            let parsedSimilarQuestions: any[] = [];
+            if (problem.similarQuestions) {
+                try {
+                    const allQuestions = JSON.parse(problem.similarQuestions);
+                    parsedSimilarQuestions = allQuestions
+                        .slice(0, 3)
+                        .map((q: any) => ({
+                            titleSlug: q.titleSlug,
+                            difficulty: q.difficulty
+                        }));
+                } catch (e) {
+                    console.error("Error parsing similarQuestions:", e);
+                }
+            }
+
+            return {
+                titleSlug,
+                questionId: problem.questionId,
+                title: problem.title,
+                content: problem.content,
+                difficulty: problem.difficulty,
+                topicTags: filteredTopicTags,
+                codeSnippets: filteredCodeSnippets,
+                exampleTestcases: problem.exampleTestcases,
+                hints: problem.hints,
+                similarQuestions: parsedSimilarQuestions
+            };
+        } catch (error) {
+            console.error(
+                `Error fetching simplified problem ${titleSlug}:`,
+                error
+            );
+            throw error;
+        }
+    }
+
     async searchProblems(
         category?: string,
         tags?: string[],

src/leetcode/leetcode-global-service.ts

@@ -192,6 +192,57 @@ export class LeetCodeGlobalService implements LeetCodeBaseService {
         }
     }
 
+    async fetchProblemSimplified(titleSlug: string): Promise<any> {
+        try {
+            const problem = await this.fetchProblem(titleSlug);
+            if (!problem) {
+                throw new Error(`Problem ${titleSlug} not found`);
+            }
+
+            const filteredTopicTags =
+                problem.topicTags?.map((tag: any) => tag.slug) || [];
+
+            const filteredCodeSnippets =
+                problem.codeSnippets?.filter((snippet: any) =>
+                    ["cpp", "python3", "java"].includes(snippet.langSlug)
+                ) || [];
+
+            let parsedSimilarQuestions: any[] = [];
+            if (problem.similarQuestions) {
+                try {
+                    const allQuestions = JSON.parse(problem.similarQuestions);
+                    parsedSimilarQuestions = allQuestions
+                        .slice(0, 3)
+                        .map((q: any) => ({
+                            titleSlug: q.titleSlug,
+                            difficulty: q.difficulty
+                        }));
+                } catch (e) {
+                    console.error("Error parsing similarQuestions:", e);
+                }
+            }
+
+            return {
+                titleSlug,
+                questionId: problem.questionId,
+                title: problem.title,
+                content: problem.content,
+                difficulty: problem.difficulty,
+                topicTags: filteredTopicTags,
+                codeSnippets: filteredCodeSnippets,
+                exampleTestcases: problem.exampleTestcases,
+                hints: problem.hints,
+                similarQuestions: parsedSimilarQuestions
+            };
+        } catch (error) {
+            console.error(
+                `Error fetching simplified problem ${titleSlug}:`,
+                error
+            );
+            throw error;
+        }
+    }
+
     async searchProblems(
         category?: string,
         tags?: string[],

src/mcp/tools/problem-tools.ts

@@ -43,7 +43,10 @@ export class ProblemToolRegistry extends ToolRegistry {
                     )
             },
             async ({ titleSlug }) => {
-                const data = await this.leetcodeService.fetchProblem(titleSlug);
+                const data =
+                    await this.leetcodeService.fetchProblemSimplified(
+                        titleSlug
+                    );
                 return {
                     content: [
                         {

tests/services/problem-services.test.ts

@@ -0,0 +1,88 @@
+import { Credential, LeetCode, LeetCodeCN } from "leetcode-query";
+import { describe, expect, it } from "vitest";
+import { LeetCodeCNService } from "../../src/leetcode/leetcode-cn-service.js";
+import { LeetCodeGlobalService } from "../../src/leetcode/leetcode-global-service.js";
+
+describe("LeetCode Problem Services", () => {
+    describe("LeetCodeGlobalService", () => {
+        const credential = new Credential();
+        const leetCodeApi = new LeetCode(credential);
+        const service = new LeetCodeGlobalService(leetCodeApi, credential);
+
+        describe("fetchProblemSimplified", () => {
+            it("should return simplified problem data", async () => {
+                const titleSlug = "two-sum";
+                const result = await service.fetchProblemSimplified(titleSlug);
+
+                expect(result).toBeDefined();
+                expect(result.titleSlug).toBe(titleSlug);
+                expect(result.title).toBe("Two Sum");
+                expect(result.questionId).toBeDefined();
+                expect(result.questionFrontendId).toBeDefined();
+                expect(result.content).toBeDefined();
+                expect(result.difficulty).toBeDefined();
+                expect(Array.isArray(result.topicTags)).toBe(true);
+                expect(Array.isArray(result.codeSnippets)).toBe(true);
+                expect(result.hints).toBeDefined();
+
+                if (result.similarQuestions) {
+                    expect(Array.isArray(result.similarQuestions)).toBe(true);
+                }
+            }, 30000);
+
+            it("should handle invalid problems correctly", async () => {
+                const invalidSlug = `invalid-problem-${Date.now()}`;
+
+                try {
+                    await service.fetchProblemSimplified(invalidSlug);
+                    expect(true).toBe(false);
+                } catch (error) {
+                    expect(error).toBeDefined();
+                }
+            }, 30000);
+        });
+    });
+
+    describe("LeetCodeCNService", () => {
+        const credential = new Credential();
+        const leetCodeApi = new LeetCodeCN(credential);
+        const service = new LeetCodeCNService(leetCodeApi, credential);
+
+        describe("fetchProblemSimplified", () => {
+            it("should return simplified problem data", async () => {
+                const titleSlug = "two-sum";
+                const result = await service.fetchProblemSimplified(titleSlug);
+
+                expect(result).toBeDefined();
+                expect(result.titleSlug).toBe(titleSlug);
+                expect(result.questionId).toBeDefined();
+                expect(result.questionFrontendId).toBeDefined();
+                expect(result.title).toBeDefined();
+                expect(result.content).toBeDefined();
+                expect(result.difficulty).toBeDefined();
+                expect(Array.isArray(result.topicTags)).toBe(true);
+                expect(Array.isArray(result.codeSnippets)).toBe(true);
+                expect(result.hints).toBeDefined();
+
+                if (result.similarQuestions) {
+                    expect(Array.isArray(result.similarQuestions)).toBe(true);
+                }
+
+                console.log(
+                    `Successfully fetched simplified data for ${titleSlug}`
+                );
+            }, 30000);
+
+            it("should handle invalid problems correctly", async () => {
+                const invalidSlug = `invalid-problem-${Date.now()}`;
+
+                try {
+                    await service.fetchProblemSimplified(invalidSlug);
+                    expect(true).toBe(false);
+                } catch (error) {
+                    expect(error).toBeDefined();
+                }
+            }, 30000);
+        });
+    });
+});