algocoach 0.1.0

package/server/services/ai-provider.ts

@@ -0,0 +1,171 @@
+import { GoogleGenAI } from "@google/genai"
+import OpenAI from "openai"
+
+const AI_TIMEOUT = 180_000
+
+export interface GenerateOptions {
+  prompt: string
+  temperature?: number
+  jsonMode?: boolean
+}
+
+export interface AIProvider {
+  generate(options: GenerateOptions): Promise<string>
+  generateStream(options: GenerateOptions): AsyncGenerator<string>
+  readonly model: string
+}
+
+export class GoogleAIProvider implements AIProvider {
+  private client: GoogleGenAI
+  readonly model: string
+
+  constructor(model?: string) {
+    const key = process.env.GEMINI_API_KEY
+    if (!key) throw new Error("GEMINI_API_KEY not set")
+    this.client = new GoogleGenAI({ apiKey: key, httpOptions: { timeout: AI_TIMEOUT } })
+    this.model = model || process.env.AI_MODEL || "gemma-4-26b-a4b-it"
+  }
+
+  async generate(options: GenerateOptions): Promise<string> {
+    let text = ""
+    for await (const chunk of this.generateStream(options)) {
+      text += chunk
+    }
+    return text
+  }
+
+  async *generateStream(options: GenerateOptions): AsyncGenerator<string> {
+    const stream = await this.client.models.generateContentStream({
+      model: this.model,
+      contents: options.prompt,
+      config: { temperature: options.temperature ?? 0.7 },
+    })
+    for await (const chunk of stream) {
+      const t = chunk.text
+      if (t) yield t
+    }
+  }
+}
+
+export class NvidiaAIProvider implements AIProvider {
+  private client: OpenAI
+  readonly model: string
+
+  constructor(model?: string) {
+    const key = process.env.NVIDIA_API_KEY
+    if (!key) throw new Error("NVIDIA_API_KEY not set")
+    this.client = new OpenAI({
+      apiKey: key,
+      baseURL: "https://integrate.api.nvidia.com/v1",
+      timeout: AI_TIMEOUT,
+      maxRetries: 2,
+    })
+    this.model = model || process.env.AI_MODEL || "meta/llama-3.1-8b-instruct"
+  }
+
+  async generate(options: GenerateOptions): Promise<string> {
+    let text = ""
+    for await (const chunk of this.generateStream(options)) {
+      text += chunk
+    }
+    return text
+  }
+
+  async *generateStream(options: GenerateOptions): AsyncGenerator<string> {
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      messages: [{ role: "user", content: options.prompt }],
+      temperature: options.temperature ?? 0.7,
+      stream: true,
+      ...(options.jsonMode ? { response_format: { type: "json_object" } } : {}),
+    })
+    for await (const chunk of stream) {
+      const content = chunk.choices?.[0]?.delta?.content
+      if (content) yield content
+    }
+  }
+}
+
+let GroqClient: any = null
+async function getGroqClient(apiKey: string) {
+  if (!GroqClient) {
+    const mod = await import("groq-sdk")
+    GroqClient = new mod.Groq({ apiKey })
+  }
+  return GroqClient
+}
+
+export class GroqAIProvider implements AIProvider {
+  readonly model: string
+  private apiKey: string
+  private clientPromise: Promise<any> | null = null
+
+  constructor(model?: string) {
+    const key = process.env.GROQ_API_KEY
+    if (!key) throw new Error("GROQ_API_KEY not set")
+    this.apiKey = key
+    this.model = model || process.env.AI_MODEL || "llama-3.3-70b-versatile"
+  }
+
+  private async client() {
+    if (!this.clientPromise) {
+      this.clientPromise = getGroqClient(this.apiKey)
+    }
+    return this.clientPromise
+  }
+
+  async generate(options: GenerateOptions): Promise<string> {
+    let text = ""
+    for await (const chunk of this.generateStream(options)) {
+      text += chunk
+    }
+    return text
+  }
+
+  async *generateStream(options: GenerateOptions): AsyncGenerator<string> {
+    const client = await this.client()
+    const stream = await client.chat.completions.create({
+      model: this.model,
+      messages: [{ role: "user", content: options.prompt }],
+      temperature: options.temperature ?? 0.7,
+      stream: true,
+      ...(options.jsonMode ? { response_format: { type: "json_object" } } : {}),
+    })
+    for await (const chunk of stream) {
+      const content = chunk.choices?.[0]?.delta?.content
+      if (content) yield content
+    }
+  }
+}
+
+export function createProvider(model?: string): AIProvider {
+  const providerName = process.env.AI_PROVIDER || "google"
+  switch (providerName) {
+    case "groq":
+      return new GroqAIProvider(model)
+    case "google":
+      return new GoogleAIProvider(model)
+    case "nvidia":
+      return new NvidiaAIProvider(model)
+    default:
+      throw new Error(`Unknown AI provider: ${providerName}. Use "google", "groq", or "nvidia"`)
+  }
+}
+
+export function extractJson(text: string): string {
+  const lastBrace = text.lastIndexOf("}")
+  const lastBracket = text.lastIndexOf("]")
+  const end = Math.max(lastBrace, lastBracket)
+  if (end === -1) return text
+
+  for (let i = end - 1; i >= 0; i--) {
+    if (text[i] === "{" || text[i] === "[") {
+      const candidate = text.slice(i, end + 1)
+      try {
+        JSON.parse(candidate)
+        return candidate
+      } catch { }
+    }
+  }
+  return text
+}

package/server/services/ai.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, expect } from "bun:test"
+import { extractJson } from "./ai-provider"
+
+describe("extractJson", () => {
+  test("extracts JSON object from end of chain-of-thought text", () => {
+    const input = `*   Input: something
+    *   Constraint: some rules
+    *   The JSON: \`{"message": "hello"}\`{"message": "hello"}`
+    const parsed = JSON.parse(extractJson(input))
+    expect(parsed.message).toBe("hello")
+  })
+
+  test("extracts JSON array from end of text", () => {
+    const input = `Here is the roadmap:
+    [
+      { "week": 1, "topic": "Arrays", "description": "Learn arrays", "problemsCount": 5 }
+    ]
+    End.`
+    const extracted = extractJson(input)
+    expect(() => JSON.parse(extracted)).not.toThrow()
+    expect(JSON.parse(extracted)[0].week).toBe(1)
+  })
+
+  test("returns original text if no JSON found", () => {
+    const input = "Just plain text without any JSON"
+    expect(extractJson(input)).toBe(input)
+  })
+
+  test("handles clean JSON input", () => {
+    const input = `{"key": "value"}`
+    expect(extractJson(input)).toBe(input)
+  })
+
+  test("handles empty string", () => {
+    expect(extractJson("")).toBe("")
+  })
+
+  test("extracts JSON with trailing backticks", () => {
+    const input = "```json\n{\"key\": \"value\"}\n```"
+    const parsed = JSON.parse(extractJson(input))
+    expect(parsed.key).toBe("value")
+  })
+
+  test("extracts JSON from markdown code blocks", () => {
+    const input = "```json\n[{\"week\":1,\"topic\":\"Arrays\"}]\n```"
+    const parsed = JSON.parse(extractJson(input))
+    expect(parsed[0].topic).toBe("Arrays")
+  })
+
+  test("picks the LAST JSON object when multiple exist", () => {
+    const input = `Some text {"first": "one"} more text {"second": "two"}`
+    const parsed = JSON.parse(extractJson(input))
+    expect(parsed.second).toBe("two")
+  })
+
+  test("picks the LAST JSON array when multiple exist", () => {
+    const input = `first [1, 2] second [3, 4]`
+    const parsed = JSON.parse(extractJson(input))
+    expect(parsed).toEqual([3, 4])
+  })
+})

package/server/services/ai.ts

@@ -0,0 +1,368 @@
+import { eq, and } from "drizzle-orm"
+import { db } from "../db"
+import { roadmapJob, roadmapPlan, userPreferences } from "../db/schema"
+import { createProvider, extractJson } from "./ai-provider"
+import { searchLeetCodeProblems } from "./leetcode-search"
+
+const provider = createProvider()
+
+interface UserPreferences {
+  experienceLevel: string
+  goals: string[]
+  weakTopics: string[]
+  targetCompanies?: string[]
+  hoursPerWeek: number
+  targetDate?: string
+}
+
+interface RoadmapWeek {
+  week: number
+  topic: string
+  description: string
+  problemsCount: number
+}
+
+function buildPrompt(prefs: UserPreferences): string {
+  return `You are a LeetCode coach creating a personalized study roadmap.
+
+User Profile:
+- Experience: ${prefs.experienceLevel}
+- Goals: ${prefs.goals.join(", ")}
+- Weak topics: ${prefs.weakTopics.join(", ")}
+- Target companies: ${prefs.targetCompanies?.join(", ") || "Not specified"}
+- Hours per week: ${prefs.hoursPerWeek}
+- Target date: ${prefs.targetDate || "No deadline"}
+
+Create a structured weekly roadmap that:
+1. Starts with fundamentals and progresses to advanced topics
+2. Prioritizes the user's weak topics
+3. Allocates more weeks to harder topics
+4. Is realistic given their hours per week
+
+Return a JSON array where each entry has: week (number), topic (string), description (string), problemsCount (number).
+
+IMPORTANT: Each topic MUST be a valid LeetCode problem tag name (e.g., "Arrays", "Strings", "Hash Table", "Dynamic Programming", "Linked List", "Binary Search", "Trees", "Graph", "Heap", "Backtracking", "Sliding Window", "Two Pointers", "Stack", "Queue", "Math", "Sorting", "Greedy", "Recursion", "Bit Manipulation"). Use STANDARD LeetCode tag names only, separated by commas if combining topics. EXAMPLE: "Binary Search, Bit Manipulation" not "Binary Search & Bit Manipulation".
+
+Aim for 4-12 weeks total depending on the user's experience and goals.`
+}
+
+export async function generateRoadmap(preferences: UserPreferences): Promise<RoadmapWeek[]> {
+  const prompt = buildPrompt(preferences)
+  const text = extractJson(await provider.generate({ prompt, temperature: 0.7, jsonMode: true }))
+  try {
+    const parsed = JSON.parse(text)
+    return Array.isArray(parsed) ? parsed : parsed.weeks || parsed.roadmap || []
+  } catch {
+    throw new Error("Failed to parse roadmap from AI response")
+  }
+}
+
+export async function processRoadmapJob(jobId: string): Promise<void> {
+  const [job] = await db.update(roadmapJob)
+    .set({ status: "processing", updatedAt: new Date() })
+    .where(and(eq(roadmapJob.id, jobId), eq(roadmapJob.status, "pending")))
+    .returning()
+  if (!job) return
+
+  const prefs = await db.query.userPreferences.findFirst({ where: eq(userPreferences.userId, job.userId) })
+  if (!prefs) {
+    await db.update(roadmapJob).set({ status: "error", error: "Complete onboarding first", updatedAt: new Date() }).where(eq(roadmapJob.id, jobId))
+    return
+  }
+
+  const prompt = buildPrompt({
+    experienceLevel: prefs.experienceLevel,
+    goals: prefs.goals,
+    weakTopics: prefs.weakTopics,
+    targetCompanies: prefs.targetCompanies ?? undefined,
+    hoursPerWeek: prefs.hoursPerWeek,
+    targetDate: prefs.targetDate?.toISOString(),
+  })
+
+  let fullText = ""
+  try {
+    for await (const chunk of provider.generateStream({ prompt, temperature: 0.7 })) {
+      fullText += chunk
+      await db.update(roadmapJob).set({ progress: fullText, updatedAt: new Date() }).where(eq(roadmapJob.id, jobId))
+    }
+
+    const cleaned = extractJson(fullText)
+    let parsed: any
+    try {
+      parsed = JSON.parse(cleaned)
+    } catch {
+      await db.update(roadmapJob).set({ status: "error", error: "Failed to parse roadmap from AI response", updatedAt: new Date() }).where(eq(roadmapJob.id, jobId))
+      return
+    }
+
+    const weeks = Array.isArray(parsed) ? parsed : parsed.weeks || parsed.roadmap || []
+
+    const existing = await db.query.roadmapPlan.findFirst({ where: eq(roadmapPlan.userId, job.userId) })
+    if (existing) {
+      await db.update(roadmapPlan).set({ weeks, currentWeek: 1, updatedAt: new Date() }).where(eq(roadmapPlan.userId, job.userId))
+    } else {
+      await db.insert(roadmapPlan).values({ id: crypto.randomUUID(), userId: job.userId, weeks, currentWeek: 1 })
+    }
+
+    await db.update(roadmapJob).set({
+      status: "done",
+      result: weeks,
+      progress: fullText,
+      updatedAt: new Date(),
+    }).where(eq(roadmapJob.id, jobId))
+  } catch (err: any) {
+    await db.update(roadmapJob).set({
+      status: "error",
+      error: err.message || "Unknown error",
+      updatedAt: new Date(),
+    }).where(eq(roadmapJob.id, jobId))
+  }
+}
+
+export function startJobProcessing(jobId: string): void {
+  processRoadmapJob(jobId).catch((err) => console.error("Roadmap job failed:", err))
+}
+
+interface LeetCodeProblem {
+  title: string
+  titleSlug: string
+  difficulty: "Easy" | "Medium" | "Hard"
+  frontendQuestionId: string
+  topicTags: { name: string; slug: string }[]
+  acRate: number
+}
+
+interface DailyTask {
+  problems: {
+    title: string
+    titleSlug: string
+    difficulty: string
+    topicTags: string[]
+    leetcodeUrl: string
+    acRate: number
+  }[]
+  explanation: string
+}
+
+export async function selectDailyProblems(params: {
+  roadmap: RoadmapWeek[]
+  currentWeek: number
+  progress: { problemId: string; status: string }[]
+  dedupCount: Record<string, number>
+  solvedSlugs: string[]
+  count?: number
+  difficultyFilter?: "EASY" | "MEDIUM" | "HARD" | "MIXED"
+  excludeSlugs?: string[]
+}): Promise<DailyTask> {
+  const {
+    roadmap, currentWeek, dedupCount, solvedSlugs,
+    count = 3, difficultyFilter = "MIXED", excludeSlugs: extraExclude = [],
+  } = params
+  const week = roadmap[currentWeek - 1]
+  if (!week) throw new Error(`Week ${currentWeek} not found in roadmap`)
+
+  const overusedSlugs = Object.entries(dedupCount)
+    .filter(([, c]) => c >= 3)
+    .map(([slug]) => slug)
+
+  const exclude = [...new Set([...overusedSlugs, ...solvedSlugs, ...extraExclude])]
+
+  const topicSlugs = parseTopicToSlugs(week.topic)
+  let searchResults = await searchLeetCodeProblems({
+    topics: topicSlugs,
+    excludeSlugs: exclude,
+    limit: 30,
+  })
+
+  if (!searchResults.length) {
+    return {
+      problems: [],
+      explanation: `No unsolved problems found for ${week.topic}. Try a different topic or reset progress.`,
+    }
+  }
+
+  if (difficultyFilter === "EASY") {
+    const filtered = searchResults.filter((p) => p.difficulty === "Easy")
+    if (filtered.length) searchResults = filtered
+  } else if (difficultyFilter === "MEDIUM") {
+    const filtered = searchResults.filter((p) => p.difficulty === "Medium")
+    if (filtered.length) searchResults = filtered
+  } else if (difficultyFilter === "HARD") {
+    const filtered = searchResults.filter((p) => p.difficulty === "Hard")
+    if (filtered.length) searchResults = filtered
+  }
+
+  const easy = searchResults.filter((p) => p.difficulty === "Easy").sort((a, b) => b.acRate - a.acRate)
+  const medium = searchResults.filter((p) => p.difficulty === "Medium").sort((a, b) => b.acRate - a.acRate)
+  const hard = searchResults.filter((p) => p.difficulty === "Hard").sort((a, b) => b.acRate - a.acRate)
+
+  const selected: LeetCodeProblem[] = []
+  const usedTags = new Set<string>()
+
+  function pickFromBucket(bucket: LeetCodeProblem[], want: number): LeetCodeProblem[] {
+    const result: LeetCodeProblem[] = []
+    const diverse = bucket.filter((p) => p.topicTags.some((t) => !usedTags.has(t.slug)))
+    const rest = bucket.filter((p) => !diverse.includes(p))
+    for (const pool of [diverse, rest]) {
+      for (const p of pool) {
+        if (result.length >= want) break
+        result.push(p)
+        p.topicTags.forEach((t) => usedTags.add(t.slug))
+      }
+    }
+    return result
+  }
+
+  if (difficultyFilter !== "MIXED") {
+    const pool = difficultyFilter === "EASY" ? easy : difficultyFilter === "MEDIUM" ? medium : hard
+    selected.push(...pickFromBucket(pool, count))
+  } else {
+    if (easy.length) selected.push(...pickFromBucket(easy, 1))
+    if (medium.length) selected.push(...pickFromBucket(medium, 1))
+    if (hard.length) selected.push(...pickFromBucket(hard, 1))
+    if (selected.length < count) {
+      const remaining = [...easy, ...medium, ...hard].filter(
+        (p) => !selected.some((s) => s.titleSlug === p.titleSlug),
+      )
+      selected.push(...pickFromBucket(remaining, count - selected.length))
+    }
+  }
+
+  const problems = selected.slice(0, count).map((p) => ({
+    title: p.title,
+    titleSlug: p.titleSlug,
+    difficulty: p.difficulty,
+    topicTags: p.topicTags.map((t) => t.name),
+    leetcodeUrl: `https://leetcode.com/problems/${p.titleSlug}/`,
+    acRate: p.acRate,
+  }))
+
+  const difficultySummary = problems.map((p) => p.difficulty).join(" → ")
+  return {
+    problems,
+    explanation: `${week.topic}: ${problems.length} problem(s) - ${difficultySummary}. Progressing from easier to harder.`,
+  }
+}
+
+const TOPIC_ALIASES: Record<string, string> = {
+  "array": "array",
+  "arrays": "array",
+  "hashing": "hash-table",
+  "hash table": "hash-table",
+  "hash tables": "hash-table",
+  "hashmap": "hash-table",
+  "hash map": "hash-table",
+  "hash maps": "hash-table",
+  "string": "string",
+  "strings": "string",
+  "two pointer": "two-pointers",
+  "two pointers": "two-pointers",
+  "sliding window": "sliding-window",
+  "binary search": "binary-search",
+  "sorting": "sorting",
+  "sort": "sorting",
+  "recursion": "recursion",
+  "recursive": "recursion",
+  "backtracking": "backtracking",
+  "stack": "stack",
+  "queue": "queue",
+  "linked list": "linked-list",
+  "linked lists": "linked-list",
+  "linkedlist": "linked-list",
+  "tree": "binary-tree",
+  "trees": "binary-tree",
+  "binary tree": "binary-tree",
+  "binary trees": "binary-tree",
+  "bst": "binary-search-tree",
+  "binary search tree": "binary-search-tree",
+  "heap": "heap-priority-queue",
+  "heaps": "heap-priority-queue",
+  "priority queue": "heap-priority-queue",
+  "graph": "graph",
+  "graphs": "graph",
+  "dynamic programming": "dynamic-programming",
+  "dp": "dynamic-programming",
+  "greedy": "greedy",
+  "bit manipulation": "bit-manipulation",
+  "bit": "bit-manipulation",
+  "trie": "trie",
+  "prefix tree": "trie",
+  "union find": "union-find",
+  "disjoint set": "union-find",
+  "divide and conquer": "divide-and-conquer",
+  "segment tree": "segment-tree",
+  "fenwick tree": "fenwick-tree",
+  "binary indexed tree": "fenwick-tree",
+  "bit (fenwick)": "fenwick-tree",
+  "topological sort": "topological-sort",
+  "topological": "topological-sort",
+  "monotonic stack": "monotonic-stack",
+  "monotonic queue": "monotonic-queue",
+  "prefix sum": "prefix-sum",
+  "prefix sums": "prefix-sum",
+  "counting": "counting",
+  "memoization": "memoization",
+  "memo": "memoization",
+  "matrix": "matrix",
+  "matrices": "matrix",
+  "math": "math",
+  "mathematics": "math",
+  "number theory": "math",
+  "geometry": "geometry",
+  "simulation": "simulation",
+  "design": "design",
+  "data stream": "data-stream",
+  "iterator": "iterator",
+  "string matching": "string-matching",
+  "kmp": "string-matching",
+  "rabin-karp": "string-matching",
+  "rolling hash": "rolling-hash",
+  "suffix array": "suffix-array",
+  "shortest path": "shortest-path",
+  "dijkstra": "shortest-path",
+  "bellman-ford": "shortest-path",
+  "mst": "minimum-spanning-tree",
+  "minimum spanning tree": "minimum-spanning-tree",
+  "scc": "strongly-connected-component",
+  "strongly connected component": "strongly-connected-component",
+  "articulation point": "articulation-point",
+  "game theory": "game-theory",
+  "combinatorics": "combinatorics",
+  "quickselect": "quickselect",
+  "bucket sort": "bucket-sort",
+  "counting sort": "counting-sort",
+  "radix sort": "radix-sort",
+  "line sweep": "line-sweep",
+  "merge sort": "merge-sort",
+  "ordered set": "ordered-set",
+  "ordered map": "ordered-map",
+  "doubly-linked list": "doubly-linked-list",
+  "circular linked list": "circular-linked-list",
+  "circular array": "circular-array",
+  "brainteaser": "brainteaser",
+  "reservoir sampling": "reservoir-sampling",
+  "rejection sampling": "rejection-sampling",
+  "probability": "probability-and-statistics",
+  "statistics": "probability-and-statistics",
+  "database": "database",
+  "sql": "sql",
+  "shell": "shell",
+  "json": "json",
+  "concurrency": "concurrency",
+}
+
+function parseTopicToSlugs(topic: string): string[] {
+  const parts = topic.split(/[,&/]/).map((s) => s.trim()).filter(Boolean)
+  const slugs = new Set<string>()
+  for (const part of parts) {
+    const normalized = part.toLowerCase().replace(/[^a-z0-9\s-]+/g, "").trim()
+    const mapped = TOPIC_ALIASES[normalized]
+    if (mapped) {
+      slugs.add(mapped)
+    } else {
+      const slug = normalized.replace(/\s+/g, "-").replace(/^-|-$/g, "")
+      if (slug) slugs.add(slug)
+    }
+  }
+  return [...slugs]
+}

package/server/services/leetcode-search.test.ts

@@ -0,0 +1,85 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { searchLeetCodeProblems } from "./leetcode-search"
+
+const MOCK_SUCCESS = {
+  data: {
+    problemsetQuestionList: {
+      total: 5,
+      questions: [
+        { acRate: 57.6, difficulty: "Easy", frontendQuestionId: "1", paidOnly: false, title: "Two Sum", titleSlug: "two-sum", topicTags: [{ name: "Array", slug: "array" }] },
+        { acRate: 47.7, difficulty: "Easy", frontendQuestionId: "14", paidOnly: false, title: "Longest Common Prefix", titleSlug: "longest-common-prefix", topicTags: [{ name: "Array", slug: "array" }] },
+        { acRate: 41.1, difficulty: "Medium", frontendQuestionId: "322", paidOnly: false, title: "Coin Change", titleSlug: "coin-change", topicTags: [{ name: "Dynamic Programming", slug: "dynamic-programming" }] },
+        { acRate: 31.2, difficulty: "Medium", frontendQuestionId: "5", paidOnly: false, title: "Longest Palindromic Substring", titleSlug: "longest-palindromic-substring", topicTags: [{ name: "String", slug: "string" }] },
+        { acRate: 60.0, difficulty: "Hard", frontendQuestionId: "100", paidOnly: true, title: "Paid Problem", titleSlug: "paid-problem", topicTags: [] },
+      ],
+    },
+  },
+}
+
+const originalFetch = globalThis.fetch
+
+describe("searchLeetCodeProblems", () => {
+  afterAll(() => { globalThis.fetch = originalFetch })
+
+  test("returns problems matching topic and difficulty", async () => {
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve(MOCK_SUCCESS) } as Response)
+    const problems = await searchLeetCodeProblems({ topics: ["array"], difficulty: "EASY" })
+    expect(problems.length).toBeGreaterThan(0)
+    expect(problems[0]).toHaveProperty("title")
+    expect(problems[0]).toHaveProperty("titleSlug")
+    expect(problems[0]).toHaveProperty("difficulty")
+    expect(problems[0]).toHaveProperty("acRate")
+    expect(problems[0]).toHaveProperty("topicTags")
+    expect(Array.isArray(problems[0].topicTags)).toBe(true)
+  })
+
+  test("filters out paid-only problems", async () => {
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve(MOCK_SUCCESS) } as Response)
+    const problems = await searchLeetCodeProblems({})
+    const paidSlugs = problems.filter(p => MOCK_SUCCESS.data.problemsetQuestionList.questions.find(q => q.titleSlug === p.titleSlug)?.paidOnly)
+    expect(paidSlugs.length).toBe(0)
+  })
+
+  test("excludes specified slugs", async () => {
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve(MOCK_SUCCESS) } as Response)
+    const problems = await searchLeetCodeProblems({ excludeSlugs: ["two-sum"], limit: 10 })
+    expect(problems.some(p => p.titleSlug === "two-sum")).toBe(false)
+  })
+
+  test("throws on API errors", async () => {
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve({ errors: [{ message: "Rate limited" }] }) } as Response)
+    expect(searchLeetCodeProblems({})).rejects.toThrow("Rate limited")
+  })
+
+  test("returns empty array when no results", async () => {
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve({ data: { problemsetQuestionList: { total: 0, questions: [] } } }) } as Response)
+    const problems = await searchLeetCodeProblems({})
+    expect(problems).toEqual([])
+  })
+
+  test("respects the limit parameter", async () => {
+    const manyResults = {
+      data: {
+        problemsetQuestionList: {
+          total: 20,
+          questions: Array.from({ length: 20 }, (_, i) => ({
+            acRate: 50, difficulty: "Easy", frontendQuestionId: String(i + 1), isPaidOnly: false,
+            title: `Problem ${i + 1}`, titleSlug: `problem-${i + 1}`, topicTags: [],
+          })),
+        },
+      },
+    }
+    globalThis.fetch = () => Promise.resolve({ json: () => Promise.resolve(manyResults) } as Response)
+    const problems = await searchLeetCodeProblems({ limit: 5 })
+    expect(problems.length).toBe(5)
+  })
+
+  test("real API: returns real problems", async () => {
+    globalThis.fetch = originalFetch
+    const problems = await searchLeetCodeProblems({ topics: ["array"], limit: 2 })
+    expect(problems.length).toBeGreaterThan(0)
+    expect(problems[0].title).toBeTruthy()
+    expect(problems[0].titleSlug).toBeTruthy()
+    expect(["Easy", "Medium", "Hard"]).toContain(problems[0].difficulty)
+  }, { timeout: 15000 })
+})