feat: add user notes feature for LeetCode CN

jinzcdev · jinzcdev · commit d906371f7fcc · 2025-04-19T23:22:10.000+08:00
diff --git a/src/index.ts b/src/index.ts
@@ -10,6 +10,7 @@ import { LeetCodeServiceFactory } from "./leetcode/leetcode-service-factory.js";
 import { registerProblemResources } from "./mcp/resources/problem-resources.js";
 import { registerSolutionResources } from "./mcp/resources/solution-resources.js";
 import { registerContestTools } from "./mcp/tools/contest-tools.js";
+import { registerNoteTools } from "./mcp/tools/note-tools.js";
 import { registerProblemTools } from "./mcp/tools/problem-tools.js";
 import { registerSolutionTools } from "./mcp/tools/solution-tools.js";
 import { registerUserTools } from "./mcp/tools/user-tools.js";
@@ -92,6 +93,7 @@ async function main() {
     registerUserTools(server, leetcodeService);
     registerContestTools(server, leetcodeService);
     registerSolutionTools(server, leetcodeService);
+    registerNoteTools(server, leetcodeService);
 
     registerProblemResources(server, leetcodeService);
     registerSolutionResources(server, leetcodeService);
diff --git a/src/leetcode/graphql/cn/note-queries.ts b/src/leetcode/graphql/cn/note-queries.ts
@@ -0,0 +1,62 @@
+/**
+ * GraphQL query for fetching user notes on LeetCode CN
+ * This query allows retrieving notes with pagination, filtering, and sorting options
+ *
+ * @param orderBy - Optional sorting criteria for notes (e.g., "ASCENDING", "DESCENDING")
+ */
+export const NOTE_AGGREGATE_QUERY = `
+query noteAggregateNote(
+    $aggregateType: AggregateNoteEnum!
+    $keyword: String
+    $orderBy: AggregateNoteSortingOrderEnum
+    $limit: Int = 100
+    $skip: Int = 0
+) {
+    noteAggregateNote(
+        aggregateType: $aggregateType
+        keyword: $keyword
+        orderBy: $orderBy
+        limit: $limit
+        skip: $skip
+    ) {
+        count
+        userNotes {
+            id
+            summary
+            content
+            ... on NoteAggregateQuestionNoteNode {
+                noteQuestion {
+                    linkTemplate
+                    questionId
+                    title
+                    translatedTitle
+                }
+            }
+        }
+    }
+}`;
+
+/**
+ * GraphQL query for fetching user notes for a specific question ID on LeetCode CN
+ */
+export const NOTE_BY_QUESTION_ID_QUERY = `
+query noteOneTargetCommonNote(
+    $noteType: NoteCommonTypeEnum!
+    $questionId: String!
+    $limit: Int = 20
+    $skip: Int = 0
+) {
+    noteOneTargetCommonNote(
+        noteType: $noteType
+        targetId: $questionId
+        limit: $limit
+        skip: $skip
+    ) {
+        count
+        userNotes {
+            id
+            summary
+            content
+        }
+    }
+}`;
diff --git a/src/leetcode/leetcode-base-service.ts b/src/leetcode/leetcode-base-service.ts
@@ -170,4 +170,41 @@ export interface LeetCodeBaseService {
      * @returns Promise resolving to the solution article detail data
      */
     fetchSolutionArticleDetail(identifier: string): Promise<any>;
+
+    /**
+     * Retrieves user notes from LeetCode with filtering and pagination options.
+     * Note: This feature is only available on LeetCode CN.
+     *
+     * @param options - Query parameters for filtering notes
+     * @param options.aggregateType - Type of notes to aggregate (e.g., "QUESTION_NOTE")
+     * @param options.keyword - Optional search term to filter notes
+     * @param options.orderBy - Optional sorting criteria for notes
+     * @param options.limit - Maximum number of notes to return
+     * @param options.skip - Number of notes to skip (for pagination)
+     * @returns Promise resolving to the filtered notes data
+     * @throws Error if not implemented or feature not supported
+     */
+    fetchUserNotes(options: {
+        aggregateType: string;
+        keyword?: string;
+        orderBy?: string;
+        limit?: number;
+        skip?: number;
+    }): Promise<any>;
+
+    /**
+     * Retrieves user notes for a specific question ID.
+     * Note: This feature is only available on LeetCode CN.
+     *
+     * @param questionId - The question ID to fetch notes for
+     * @param limit - Maximum number of notes to return
+     * @param skip - Number of notes to skip (for pagination)
+     * @returns Promise resolving to the notes data for the specified question
+     * @throws Error if not implemented or feature not supported
+     */
+    fetchNotesByQuestionId(
+        questionId: string,
+        limit?: number,
+        skip?: number
+    ): Promise<any>;
 }
diff --git a/src/leetcode/leetcode-cn-service.ts b/src/leetcode/leetcode-cn-service.ts
@@ -1,4 +1,8 @@
 import { Credential, LeetCodeCN } from "leetcode-query";
+import {
+    NOTE_AGGREGATE_QUERY,
+    NOTE_BY_QUESTION_ID_QUERY
+} from "./graphql/cn/note-queries.js";
 import { SEARCH_PROBLEMS_QUERY } from "./graphql/cn/search-problems.js";
 import { SOLUTION_ARTICLE_DETAIL_QUERY } from "./graphql/cn/solution-article-detail.js";
 import { SOLUTION_ARTICLES_QUERY } from "./graphql/cn/solution-articles.js";
@@ -358,6 +362,107 @@ export class LeetCodeCNService implements LeetCodeBaseService {
         }
     }
 
+    /**
+     * Retrieves user notes from LeetCode CN with filtering and pagination options.
+     * Available only on LeetCode CN platform.
+     *
+     * @param options - Query parameters for filtering notes
+     * @param options.aggregateType - Type of notes to aggregate (e.g., "QUESTION_NOTE")
+     * @param options.keyword - Optional search term to filter notes
+     * @param options.orderBy - Optional sorting criteria for notes
+     * @param options.limit - Maximum number of notes to return
+     * @param options.skip - Number of notes to skip (for pagination)
+     * @returns Promise resolving to the filtered notes data
+     */
+    async fetchUserNotes(options: {
+        aggregateType: string;
+        keyword?: string;
+        orderBy?: string;
+        limit?: number;
+        skip?: number;
+    }): Promise<any> {
+        if (!this.isAuthenticated()) {
+            throw new Error("Authentication required to fetch user notes");
+        }
+
+        try {
+            const variables = {
+                aggregateType: options.aggregateType,
+                keyword: options.keyword,
+                orderBy: options.orderBy || "DESCENDING",
+                limit: options.limit || 20,
+                skip: options.skip || 0
+            };
+
+            return await this.leetCodeApi
+                .graphql({
+                    query: NOTE_AGGREGATE_QUERY,
+                    variables
+                })
+                .then((response) => {
+                    return (
+                        response.data?.noteAggregateNote || {
+                            count: 0,
+                            userNotes: []
+                        }
+                    );
+                });
+        } catch (error) {
+            console.error(`Error fetching user notes:`, error);
+            throw error;
+        }
+    }
+
+    /**
+     * Retrieves user notes for a specific question ID.
+     * Available only on LeetCode CN platform.
+     *
+     * @param questionId - The question ID to fetch notes for
+     * @param limit - Maximum number of notes to return (default: 20)
+     * @param skip - Number of notes to skip (default: 0)
+     * @returns Promise resolving to the notes data for the specified question
+     */
+    async fetchNotesByQuestionId(
+        questionId: string,
+        limit: number = 20,
+        skip: number = 0
+    ): Promise<any> {
+        if (!this.isAuthenticated()) {
+            throw new Error(
+                "Authentication required to fetch notes by question ID"
+            );
+        }
+
+        try {
+            const variables = {
+                noteType: "COMMON_QUESTION",
+                questionId: questionId,
+                limit,
+                skip
+            };
+
+            return await this.leetCodeApi
+                .graphql({
+                    query: NOTE_BY_QUESTION_ID_QUERY,
+                    variables
+                })
+                .then((response) => {
+                    return (
+                        response.data?.noteOneTargetCommonNote || {
+                            count: 0,
+                            userNotes: []
+                        }
+                    );
+                });
+        } catch (error) {
+            console.error(
+                `Error fetching notes for question ${questionId}:`,
+                error
+            );
+            throw error;
+        }
+    }
+
     isAuthenticated(): boolean {
         return (
             !!this.credential &&
diff --git a/src/leetcode/leetcode-global-service.ts b/src/leetcode/leetcode-global-service.ts
@@ -350,6 +350,40 @@ export class LeetCodeGlobalService implements LeetCodeBaseService {
         }
     }
 
+    /**
+     * Note feature is not supported in LeetCode Global.
+     * This method is implemented to satisfy the interface but will always throw an error.
+     *
+     * @param options - Query parameters (not used)
+     * @throws Error indicating the feature is not supported on Global platform
+     */
+    async fetchUserNotes(options: {
+        aggregateType: string;
+        keyword?: string;
+        orderBy?: string;
+        limit?: number;
+        skip?: number;
+    }): Promise<any> {
+        throw new Error("Notes feature is not supported in LeetCode Global");
+    }
+
+    /**
+     * Note feature is not supported in LeetCode Global.
+     * This method is implemented to satisfy the interface but will always throw an error.
+     *
+     * @param questionId - The question ID (not used)
+     * @param limit - Maximum number of notes (not used)
+     * @param skip - Pagination offset (not used)
+     * @throws Error indicating the feature is not supported on Global platform
+     */
+    async fetchNotesByQuestionId(
+        questionId: string,
+        limit?: number,
+        skip?: number
+    ): Promise<any> {
+        throw new Error("Notes feature is not supported in LeetCode Global");
+    }
+
     isAuthenticated(): boolean {
         return (
             !!this.credential &&
diff --git a/src/mcp/tools/note-tools.ts b/src/mcp/tools/note-tools.ts
