algocoach 0.1.0

package/server/services/leetcode-search.ts

@@ -0,0 +1,84 @@
+const LEETCODE_API = "https://leetcode.com/graphql";
+
+interface LeetCodeProblem {
+  title: string
+  titleSlug: string
+  difficulty: "Easy" | "Medium" | "Hard"
+  frontendQuestionId: string
+  topicTags: { name: string; slug: string }[]
+  acRate: number
+  paidOnly: boolean
+}
+
+interface LeetCodeSearchResult {
+  problemsetQuestionList: {
+    total: number
+    questions: LeetCodeProblem[]
+  }
+}
+
+const searchQuery = `
+  query problemsetQuestionList($categorySlug: String, $limit: Int, $skip: Int, $filters: QuestionListFilterInput) {
+    problemsetQuestionList: questionList(
+      categorySlug: $categorySlug
+      limit: $limit
+      skip: $skip
+      filters: $filters
+    ) {
+      total: totalNum
+      questions: data {
+        acRate
+        difficulty
+        frontendQuestionId: questionFrontendId
+        paidOnly: isPaidOnly
+        title
+        titleSlug
+        topicTags {
+          name
+          slug
+        }
+      }
+    }
+  }
+`;
+
+export async function searchLeetCodeProblems(params: {
+  topics?: string[]
+  difficulty?: "EASY" | "MEDIUM" | "HARD"
+  limit?: number
+  excludeSlugs?: string[]
+}): Promise<LeetCodeProblem[]> {
+  const { topics, difficulty, limit = 15, excludeSlugs = [] } = params
+
+  const filters: Record<string, unknown> = {}
+  if (topics?.length) filters.tags = topics
+  if (difficulty) filters.difficulty = difficulty
+
+  const res = await fetch(LEETCODE_API, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      query: searchQuery,
+      variables: {
+        categorySlug: "",
+        limit: limit + excludeSlugs.length,
+        skip: 0,
+        filters,
+      },
+    }),
+  })
+
+  const json = await res.json() as { data?: LeetCodeSearchResult; errors?: { message: string }[] }
+  if (json.errors?.length) {
+    throw new Error(json.errors[0].message || "LeetCode search API error")
+  }
+
+  let problems = json.data?.problemsetQuestionList?.questions || []
+  problems = problems.filter((p) => !p.paidOnly)
+
+  if (excludeSlugs.length) {
+    problems = problems.filter((p) => !excludeSlugs.includes(p.titleSlug))
+  }
+
+  return problems.slice(0, limit)
+}

package/server/services/leetcode.ts

@@ -0,0 +1,84 @@
+const LEETCODE_API = "https://leetcode.com/graphql";
+
+const getLeetcodeDataQuery = `
+  query GetLeetCodeProfile($username: String!) {
+    matchedUser(username: $username) {
+      username
+      submitStats {
+        acSubmissionNum {
+          difficulty
+          count
+        }
+      }
+    }
+    userContestRanking(username: $username) {
+      rating
+      globalRanking
+    }
+  }
+`;
+
+export interface LeetCodeStats {
+  username: string
+  totalSolved: number
+  easySolved: number
+  mediumSolved: number
+  hardSolved: number
+  rating: number | null
+  ranking: number | null
+}
+
+async function graphqlRequest<T>(query: string, variables: Record<string, unknown>): Promise<T> {
+  const res = await fetch(LEETCODE_API, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query, variables }),
+  })
+  const json = await res.json() as { data: T; errors?: { message: string }[] }
+  if (json.errors?.length) {
+    throw new Error(json.errors[0].message || "LeetCode API error")
+  }
+  return json.data
+}
+
+export async function validateUsername(username: string): Promise<boolean> {
+  try {
+    const data = await graphqlRequest<{ matchedUser: { username: string } | null }>(
+      `query ($username: String!) { matchedUser(username: $username) { username } }`,
+      { username },
+    )
+    return data.matchedUser !== null
+  } catch {
+    return false
+  }
+}
+
+export async function fetchLeetcodeStats(username: string): Promise<LeetCodeStats> {
+  const valid = await validateUsername(username)
+  if (!valid) throw new Error("LeetCode username not found")
+
+  const data = await graphqlRequest<{
+    matchedUser: {
+      username: string
+      submitStats: {
+        acSubmissionNum: { difficulty: string; count: number }[]
+      }
+    }
+    userContestRanking: { rating: number; globalRanking: number } | null
+  }>(getLeetcodeDataQuery, { username })
+
+  const counts: Record<string, number> = {}
+  for (const entry of data.matchedUser.submitStats.acSubmissionNum) {
+    counts[entry.difficulty.toLowerCase()] = entry.count
+  }
+
+  return {
+    username: data.matchedUser.username,
+    totalSolved: counts.all || 0,
+    easySolved: counts.easy || 0,
+    mediumSolved: counts.medium || 0,
+    hardSolved: counts.hard || 0,
+    rating: data.userContestRanking?.rating ?? null,
+    ranking: data.userContestRanking?.globalRanking ?? null,
+  }
+}