algocoach 0.1.0

package/server/local-dev/test-ai.ts

@@ -0,0 +1,88 @@
+
+import { getDb } from "../db"
+import { userPreferences, roadmapPlan } from "../db/schema"
+import { eq } from "drizzle-orm"
+import { createProvider, extractJson } from "../services/ai-provider"
+
+const USER_ID = process.env.LOCAL_USER_ID || "dev-user-id"
+
+async function main() {
+  console.log("🔧 Local Dev: AI Provider Test\n")
+
+  console.log("Environment:")
+  console.log(`  AI_PROVIDER: ${process.env.AI_PROVIDER || "(not set, default: google)"}`)
+  console.log(`  AI_MODEL: ${process.env.AI_MODEL || "(not set, using provider default)"}`)
+  console.log(`  GEMINI_API_KEY: ${process.env.GEMINI_API_KEY ? "✅ set" : "❌ not set"}`)
+  console.log(`  GROQ_API_KEY: ${process.env.GROQ_API_KEY ? "✅ set" : "❌ not set"}`)
+  console.log("")
+
+  console.log("1️⃣  Creating provider...")
+  let provider
+  try {
+    provider = createProvider()
+    console.log(`   ✅ Provider: ${provider.constructor.name}, model: ${provider.model}\n`)
+  } catch (e: any) {
+    console.log(`   ❌ ${e.message}\n`)
+    process.exit(1)
+  }
+
+  console.log("2️⃣  Testing simple generation...")
+  let rawText = ""
+  try {
+    rawText = await provider.generate({
+      prompt: "Say hello as JSON: {\"message\": \"hello\"}",
+      temperature: 0.1,
+      jsonMode: true,
+    })
+    const cleaned = extractJson(rawText)
+    const parsed = JSON.parse(cleaned)
+    console.log(`   ✅ Response: ${JSON.stringify(parsed)}\n`)
+  } catch (e: any) {
+    console.log(`   ❌ ${e.message}`)
+    console.log(`   Raw AI response (first 500 chars):\n${"─".repeat(60)}\n${rawText.slice(0, 500)}\n${"─".repeat(60)}`)
+    console.log(`   Cleaned (first 500 chars):\n${"─".repeat(60)}\n${extractJson(rawText).slice(0, 500)}\n${"─".repeat(60)}`)
+    process.exit(1)
+  }
+
+  console.log("3️⃣  Testing roadmap generation...")
+  try {
+    const prefs = await getDb().query.userPreferences.findFirst({
+      where: eq(userPreferences.userId, USER_ID),
+    })
+    if (!prefs) {
+      console.log("   ⏭️  No user preferences found (run onboarding first or create manually)")
+    } else {
+      const prompt = `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"}
+
+Return a JSON array where each entry has: week (number), topic (string), description (string), problemsCount (number).
+Aim for 4 weeks.`
+
+      rawText = ""
+      rawText = await provider.generate({ prompt, temperature: 0.7, jsonMode: true })
+      const cleaned = extractJson(rawText)
+      const parsed = JSON.parse(cleaned)
+      const weeks = Array.isArray(parsed) ? parsed : parsed.weeks || parsed.roadmap || []
+      console.log(`   ✅ Generated ${weeks.length} weeks`)
+      weeks.forEach((w: any) => console.log(`      Week ${w.week}: ${w.topic}`))
+    }
+  } catch (e: any) {
+    console.log(`   ❌ ${e.message}`)
+    console.log(`   Raw AI response (first 500 chars):\n${"─".repeat(60)}\n${rawText.slice(0, 500)}\n${"─".repeat(60)}`)
+    if (e.stack) console.log(`      Stack: ${e.stack.split("\n").slice(0, 3).join("\n      ")}`)
+  }
+
+  console.log("\n✅ Done")
+}
+
+main().catch((e) => {
+  console.error("Fatal:", e)
+  process.exit(1)
+})

package/server/middleware/auth.ts

@@ -0,0 +1,30 @@
+import { createMiddleware } from 'hono/factory'
+import { auth } from '../auth'
+import { db } from '../db'
+import { user } from '../db/schema'
+import { eq } from 'drizzle-orm'
+import { isLocalDev, DEV_USER_ID } from '../local-dev'
+
+export const authMiddleware = createMiddleware(async (c, next) => {
+  if (isLocalDev()) {
+    const userId = process.env.LOCAL_USER_ID || DEV_USER_ID
+    const existing = await db.query.user.findFirst({ where: eq(user.id, userId) })
+    if (!existing) {
+      await db.insert(user).values({
+        id: userId,
+        name: 'Dev User',
+        email: 'dev@local.dev',
+        emailVerified: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })
+    }
+    c.set('userId', userId)
+    await next()
+    return
+  }
+  const session = await auth.api.getSession({ headers: c.req.raw.headers })
+  if (!session) return c.json({ error: 'Unauthorized' }, 401)
+  c.set('userId', session.user.id)
+  await next()
+})

package/server/middleware/rate-limit.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect } from "bun:test"
+
+describe("rateLimit middleware", () => {
+  test("allows requests within limit", async () => {
+    const { rateLimit } = await import("./rate-limit")
+    const middleware = rateLimit(5, 60000)
+
+    let status = 0
+    const c = {
+      req: { header: () => "127.0.0.1", path: "/test" },
+      json: (body: any, s?: number) => { status = s || 200; return body },
+    } as any
+
+    for (let i = 0; i < 5; i++) {
+      status = 0
+      let calledNext = false
+      await middleware(c, () => { calledNext = true; return Promise.resolve() })
+      expect(calledNext).toBe(true)
+      expect(status).not.toBe(429)
+    }
+  })
+
+  test("blocks requests exceeding limit", async () => {
+    // Clear module cache to get fresh rate limit store
+    const { rateLimit } = await import("./rate-limit")
+    const middleware = rateLimit(3, 60000)
+
+    let status = 0
+    let body: any = null
+    const c = {
+      req: { header: () => "127.0.0.1", path: "/test-block" },
+      json: (b: any, s?: number) => { status = s || 200; body = b; return body },
+    } as any
+
+    for (let i = 0; i < 3; i++) {
+      status = 0
+      await middleware(c, () => Promise.resolve())
+    }
+    expect(status).not.toBe(429)
+
+    // 4th request should be blocked
+    status = 0
+    await middleware(c, () => Promise.resolve())
+    expect(status).toBe(429)
+    expect(body.error).toContain("Too many requests")
+  })
+
+  test("resets window after expiry", async () => {
+    const { rateLimit } = await import("./rate-limit")
+    const middleware = rateLimit(2, 50) // 50ms window
+
+    let status = 0
+    const c = {
+      req: { header: () => "127.0.0.2", path: "/test-reset" },
+      json: (b: any, s?: number) => { status = s || 200; return b },
+    } as any
+
+    // Use up the limit
+    await middleware(c, () => Promise.resolve())
+    await middleware(c, () => Promise.resolve())
+
+    // 3rd should block
+    status = 0
+    await middleware(c, () => Promise.resolve())
+    expect(status).toBe(429)
+
+    // Wait for window to expire
+    await new Promise(r => setTimeout(r, 60))
+
+    // Should be allowed again
+    status = 0
+    let calledNext = false
+    await middleware(c, () => { calledNext = true; return Promise.resolve() })
+    expect(calledNext).toBe(true)
+    expect(status).not.toBe(429)
+  })
+})

package/server/middleware/rate-limit.ts

@@ -0,0 +1,30 @@
+import { createMiddleware } from 'hono/factory'
+
+interface Entry {
+  count: number
+  resetAt: number
+}
+
+const store = new Map<string, Entry>()
+
+export function rateLimit(maxRequests: number, windowMs: number) {
+  return createMiddleware(async (c, next) => {
+    const ip = c.req.header('x-forwarded-for') || c.req.header('x-real-ip') || 'unknown'
+    const key = `${ip}:${c.req.path}`
+    const now = Date.now()
+
+    let entry = store.get(key)
+    if (!entry || now > entry.resetAt) {
+      entry = { count: 0, resetAt: now + windowMs }
+      store.set(key, entry)
+    }
+
+    entry.count++
+
+    if (entry.count > maxRequests) {
+      return c.json({ error: 'Too many requests, please try again later' }, 429)
+    }
+
+    await next()
+  })
+}

package/server/routes/leetcode.ts

@@ -0,0 +1,189 @@
+import { Hono } from 'hono'
+import { z } from 'zod'
+import { db } from '../db'
+import { leetcodeAccount, dailyProgress } from '../db/schema'
+import { fetchLeetcodeStats } from '../services/leetcode'
+import { linkLeetcodeSchema, logProblemSchema } from '../lib/validation'
+import { authMiddleware } from '../middleware/auth'
+import { eq, and, desc } from 'drizzle-orm'
+
+const app = new Hono<{ Variables: { userId: string } }>()
+app.use('/*', authMiddleware)
+
+app.post('/link', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const body = await c.req.json()
+    const parsed = linkLeetcodeSchema.parse(body)
+
+    const stats = await fetchLeetcodeStats(parsed.leetcodeUsername)
+
+    const existing = await db.query.leetcodeAccount.findFirst({
+      where: eq(leetcodeAccount.userId, userId),
+    })
+
+    const entry = {
+      leetcodeUsername: stats.username,
+      totalSolved: stats.totalSolved,
+      easySolved: stats.easySolved,
+      mediumSolved: stats.mediumSolved,
+      hardSolved: stats.hardSolved,
+      updatedAt: new Date(),
+    }
+
+    if (existing) {
+      await db.update(leetcodeAccount).set(entry).where(eq(leetcodeAccount.userId, userId))
+    } else {
+      await db.insert(leetcodeAccount).values({ id: crypto.randomUUID(), userId, ...entry })
+    }
+
+    return c.json({ success: true, data: { ...entry, lastFetchedAt: new Date().toISOString() } })
+  } catch (err: any) {
+    if (err instanceof z.ZodError) return c.json({ success: false, errors: err.issues }, 400)
+    return c.json({ success: false, error: err.message || 'Failed to link account' }, 400)
+  }
+})
+
+app.get('/stats', async (c) => {
+  try {
+    const userId = c.get('userId')
+
+    const account = await db.query.leetcodeAccount.findFirst({
+      where: eq(leetcodeAccount.userId, userId),
+    })
+
+    if (!account) return c.json({ success: false, error: 'No LeetCode account linked' }, 404)
+
+    const stale = !account.updatedAt || Date.now() - new Date(account.updatedAt).getTime() > 3_600_000
+
+    if (stale) {
+      try {
+        const stats = await fetchLeetcodeStats(account.leetcodeUsername)
+        await db.update(leetcodeAccount).set({
+          totalSolved: stats.totalSolved,
+          easySolved: stats.easySolved,
+          mediumSolved: stats.mediumSolved,
+          hardSolved: stats.hardSolved,
+          updatedAt: new Date(),
+        }).where(eq(leetcodeAccount.userId, userId))
+        return c.json({ success: true, data: { ...account, ...stats, updatedAt: new Date().toISOString() } })
+      } catch {
+        return c.json({ success: true, data: account })
+      }
+    }
+
+    return c.json({ success: true, data: account })
+  } catch (err: any) {
+    return c.json({ success: false, error: err.message || 'Failed to fetch stats' }, 500)
+  }
+})
+
+app.post('/refresh', async (c) => {
+  try {
+    const userId = c.get('userId')
+
+    const account = await db.query.leetcodeAccount.findFirst({
+      where: eq(leetcodeAccount.userId, userId),
+    })
+
+    if (!account) return c.json({ success: false, error: 'No LeetCode account linked' }, 404)
+
+    const stats = await fetchLeetcodeStats(account.leetcodeUsername)
+
+    await db.update(leetcodeAccount).set({
+      totalSolved: stats.totalSolved,
+      easySolved: stats.easySolved,
+      mediumSolved: stats.mediumSolved,
+      hardSolved: stats.hardSolved,
+      updatedAt: new Date(),
+    }).where(eq(leetcodeAccount.userId, userId))
+
+    return c.json({ success: true, data: { ...stats, lastFetchedAt: new Date().toISOString() } })
+  } catch (err: any) {
+    return c.json({ success: false, error: err.message || 'Failed to refresh stats' }, 500)
+  }
+})
+
+app.post('/log', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const body = await c.req.json()
+    const parsed = logProblemSchema.parse(body)
+
+    const existing = await db.query.dailyProgress.findFirst({
+      where: and(
+        eq(dailyProgress.userId, userId),
+        eq(dailyProgress.problemId, parsed.problemId),
+      ),
+    })
+
+    if (existing) {
+      return c.json({ success: true, data: existing })
+    }
+
+    const entry = {
+      id: crypto.randomUUID(),
+      userId,
+      date: new Date(),
+      problemName: parsed.problemName,
+      difficulty: parsed.difficulty,
+      problemId: parsed.problemId,
+      topics: parsed.topics,
+      status: 'IN_PROGRESS' as const,
+    }
+
+    await db.insert(dailyProgress).values(entry)
+
+    return c.json({ success: true, data: entry }, 201)
+  } catch (err: any) {
+    if (err instanceof z.ZodError) return c.json({ success: false, errors: err.issues }, 400)
+    return c.json({ success: false, error: err.message || 'Failed to log problem' }, 500)
+  }
+})
+
+app.patch('/log/:problemId', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const problemId = c.req.param('problemId')
+
+    const existing = await db.query.dailyProgress.findFirst({
+      where: and(
+        eq(dailyProgress.userId, userId),
+        eq(dailyProgress.problemId, problemId),
+      ),
+    })
+
+    if (!existing) return c.json({ success: false, error: 'Problem not found' }, 404)
+
+    await db.update(dailyProgress).set({ status: 'SOLVED' }).where(
+      and(eq(dailyProgress.userId, userId), eq(dailyProgress.problemId, problemId)),
+    )
+
+    return c.json({ success: true, data: { ...existing, status: 'SOLVED' } })
+  } catch (err: any) {
+    return c.json({ success: false, error: err.message || 'Failed to update problem' }, 500)
+  }
+})
+
+app.get('/log', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const status = c.req.query('status')
+
+    const conditions = [eq(dailyProgress.userId, userId)]
+    if (status === 'SOLVED' || status === 'IN_PROGRESS') {
+      conditions.push(eq(dailyProgress.status, status))
+    }
+
+    const problems = await db.query.dailyProgress.findMany({
+      where: and(...conditions),
+      orderBy: desc(dailyProgress.date),
+    })
+
+    return c.json({ success: true, data: problems })
+  } catch (err: any) {
+    return c.json({ success: false, error: err.message || 'Failed to fetch problems' }, 500)
+  }
+})
+
+export default app

package/server/routes/onboard.ts

@@ -0,0 +1,75 @@
+import { Hono } from 'hono'
+import { z } from 'zod'
+import { db } from '../db'
+import { userPreferences, roadmapPlan } from '../db/schema'
+import { authMiddleware } from '../middleware/auth'
+import { eq } from 'drizzle-orm'
+import { generateRoadmap } from '../services/ai'
+
+const app = new Hono<{ Variables: { userId: string } }>()
+app.use('/*', authMiddleware)
+
+const onboardSchema = z.object({
+  experienceLevel: z.enum(['beginner', 'intermediate', 'advanced', 'competitive']),
+  goals: z.array(z.string()).min(1, 'Select at least one goal'),
+  weakTopics: z.array(z.string()).min(1, 'Select at least one weak topic'),
+  targetCompanies: z.array(z.string()).optional(),
+  hoursPerWeek: z.number().int().min(1).max(168),
+  targetDate: z.string().optional(),
+})
+
+app.get('/', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const prefs = await db.query.userPreferences.findFirst({
+      where: eq(userPreferences.userId, userId),
+    })
+    if (!prefs) return c.json({ success: false, onboarded: false }, 404)
+    return c.json({ success: true, onboarded: true, data: prefs })
+  } catch (err: any) {
+    return c.json({ success: false, error: err.message }, 500)
+  }
+})
+
+app.post('/', async (c) => {
+  try {
+    const userId = c.get('userId')
+    const body = await c.req.json()
+    const parsed = onboardSchema.parse(body)
+
+    const prefs = {
+      userId,
+      experienceLevel: parsed.experienceLevel,
+      goals: parsed.goals,
+      weakTopics: parsed.weakTopics,
+      targetCompanies: parsed.targetCompanies || [],
+      hoursPerWeek: parsed.hoursPerWeek,
+      targetDate: parsed.targetDate ? new Date(parsed.targetDate) : null,
+    }
+
+    await db.insert(userPreferences).values(prefs).onConflictDoUpdate({
+      target: userPreferences.userId,
+      set: { ...prefs, updatedAt: new Date() },
+    })
+
+    const existingPlan = await db.query.roadmapPlan.findFirst({
+      where: eq(roadmapPlan.userId, userId),
+    })
+
+    if (!existingPlan) {
+      await db.insert(roadmapPlan).values({
+        id: crypto.randomUUID(),
+        userId,
+        weeks: [],
+        currentWeek: 1,
+      })
+    }
+
+    return c.json({ success: true, data: { roadmap: existingPlan?.weeks || null } }, 201)
+  } catch (err: any) {
+    if (err instanceof z.ZodError) return c.json({ success: false, errors: err.issues }, 400)
+    return c.json({ success: false, error: err.message || 'Failed to save preferences' }, 500)
+  }
+})
+
+export default app