-
Weekly Goals
-
- {goals.map((goal, index) => (
-
-
-
- {goal.title}
-
-
- {goal.current}/{goal.target}
-
-
-
-
- ))}
+
+
+ Weekly Goals
+
+
+
+ {goals.map((goal) => {
+ const pct = Math.min(100, (goal.current / goal.target) * 100);
+
+ return (
+
+
+
+ {goal.title}
+
+
+ {goal.current}/{goal.target}
+
+
+
+
+ );
+ })}
+
);
}
diff --git a/src/app/globals.css b/src/app/globals.css
index a461c50..1d9e790 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1 +1,31 @@
-@import "tailwindcss";
\ No newline at end of file
+@import "tailwindcss";
+@custom-variant dark (&:where(.dark, .dark *));
+
+:root {
+ color-scheme: light;
+}
+
+.dark {
+ color-scheme: dark;
+}
+
+* {
+ box-sizing: border-box;
+}
+
+html,
+body {
+ width: 100%;
+ height: 100%;
+}
+
+body {
+ margin: 0;
+ background-color: #f5f6f8;
+ color: #111827;
+}
+
+.dark body {
+ background-color: #0a0a0a;
+ color: #f3f4f6;
+}
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index 3d007a8..78e4de4 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -1,28 +1,39 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
import "./globals.css";
-import { Inter } from "next/font/google";
-import { AuthProvider } from "@/context/AuthContext";
-import { Toaster } from "react-hot-toast";
+import { Providers } from "./providers";
+import WebVitalsReporter from "./WebVitalsReporter";
-const inter = Inter({ subsets: ["latin"] });
+const geistSans = Geist({
+ variable: "--font-geist-sans",
+ subsets: ["latin"],
+});
-export const metadata = {
- title: "MLBoost - LeetCode for Machine Learning",
- description: "Master Machine Learning through practice problems.",
+const geistMono = Geist_Mono({
+ variable: "--font-geist-mono",
+ subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+ title: "MLBoost",
+ description: "Interactive ML coding practice platform",
};
export default function RootLayout({
children,
-}: {
+}: Readonly<{
children: React.ReactNode;
-}) {
+}>) {
return (
-
-
-
-
+
+
+
+
{children}
-
+
);
-}
\ No newline at end of file
+}
diff --git a/src/app/learn/page.tsx b/src/app/learn/page.tsx
new file mode 100644
index 0000000..24c1049
--- /dev/null
+++ b/src/app/learn/page.tsx
@@ -0,0 +1,86 @@
+"use client";
+
+import MainLayout from "../components/MainLayout";
+
+const TRACKS = [
+ {
+ id: "t1",
+ title: "ML Foundations",
+ description: "Linear models, overfitting, feature scaling, and evaluation.",
+ lessons: 18,
+ progress: 72,
+ },
+ {
+ id: "t2",
+ title: "Pandas for Interviews",
+ description: "Joins, groupby, window operations, and common data transforms.",
+ lessons: 14,
+ progress: 38,
+ },
+ {
+ id: "t3",
+ title: "Model Selection",
+ description: "Cross-validation, hyperparameter tuning, and proper split strategy.",
+ lessons: 11,
+ progress: 12,
+ },
+];
+
+const MODULES = [
+ "Bias-Variance Tradeoff",
+ "Confusion Matrix and F1",
+ "Regularization in Practice",
+ "Feature Drift Detection",
+];
+
+export default function LearnPage() {
+ return (
+
+
+
+
+ Learning Tracks
+
+
+ {TRACKS.map((track) => (
+
+
+
+
{track.title}
+
{track.description}
+
+
{track.lessons} lessons
+
+ ))}
+
+
+ );
+}
diff --git a/src/app/login/page.test.tsx b/src/app/login/page.test.tsx
new file mode 100644
index 0000000..600d5b3
--- /dev/null
+++ b/src/app/login/page.test.tsx
@@ -0,0 +1,78 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import LoginPage from "./page";
+
+const replaceMock = vi.fn();
+const loginMock = vi.fn().mockResolvedValue(undefined);
+const signupMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock("next/navigation", () => ({
+ useRouter: () => ({
+ replace: replaceMock,
+ }),
+ useSearchParams: () => new URLSearchParams("redirect=/problems/f1-score-from-scratch"),
+}));
+
+vi.mock("@/context/AuthContext", () => ({
+ useAuth: () => ({
+ login: loginMock,
+ signup: signupMock,
+ isLoading: false,
+ }),
+}));
+
+describe("LoginPage", () => {
+ beforeEach(() => {
+ replaceMock.mockClear();
+ loginMock.mockClear();
+ signupMock.mockClear();
+ });
+
+ it("submits login and redirects to redirect param", async () => {
+ render(
);
+
+ fireEvent.change(screen.getByLabelText(/email/i), {
+ target: { value: "test@example.com" },
+ });
+ fireEvent.change(screen.getByLabelText(/password/i), {
+ target: { value: "password123" },
+ });
+
+ fireEvent.click(screen.getByRole("button", { name: "Sign in" }));
+
+ await waitFor(() => {
+ expect(loginMock).toHaveBeenCalledWith({
+ email: "test@example.com",
+ password: "password123",
+ });
+ });
+
+ expect(replaceMock).toHaveBeenCalledWith("/problems/f1-score-from-scratch");
+ });
+
+ it("submits signup payload", async () => {
+ render(
);
+
+ fireEvent.click(screen.getByRole("button", { name: "Sign up" }));
+
+ fireEvent.change(screen.getByLabelText(/name/i), {
+ target: { value: "Ada" },
+ });
+ fireEvent.change(screen.getByLabelText(/email/i), {
+ target: { value: "ada@example.com" },
+ });
+ fireEvent.change(screen.getByLabelText(/password/i), {
+ target: { value: "password123" },
+ });
+
+ fireEvent.click(screen.getByRole("button", { name: "Create account" }));
+
+ await waitFor(() => {
+ expect(signupMock).toHaveBeenCalledWith({
+ name: "Ada",
+ email: "ada@example.com",
+ password: "password123",
+ });
+ });
+ });
+});
diff --git a/src/app/login/page.tsx b/src/app/login/page.tsx
index 89ee175..0e9e628 100644
--- a/src/app/login/page.tsx
+++ b/src/app/login/page.tsx
@@ -1,77 +1,192 @@
"use client";
-import { useState } from "react";
-import Link from "next/link";
+import { FormEvent, Suspense, useMemo, useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { Loader2 } from "lucide-react";
import { useAuth } from "@/context/AuthContext";
-import toast from "react-hot-toast";
+import ThemeSwitcher from "@/app/components/ThemeSwitcher";
-export default function LoginPage() {
- const { login } = useAuth();
+type AuthMode = "login" | "signup";
+
+function sanitizeRedirect(path: string | null): string {
+ if (!path || !path.startsWith("/")) {
+ return "/problems";
+ }
+ if (path.startsWith("//")) {
+ return "/problems";
+ }
+ return path;
+}
+
+function LoginForm() {
+ const router = useRouter();
+ const searchParams = useSearchParams();
+ const { login, signup, isLoading } = useAuth();
+
+ const [mode, setMode] = useState
("login");
+ const [name, setName] = useState("");
const [email, setEmail] = useState("");
const [password, setPassword] = useState("");
- const [isLoading, setIsLoading] = useState(false);
+ const [errorMessage, setErrorMessage] = useState("");
- const handleSubmit = async (e: React.FormEvent) => {
- e.preventDefault();
- setIsLoading(true);
+ const redirectTo = useMemo(
+ () => sanitizeRedirect(searchParams.get("redirect")),
+ [searchParams]
+ );
+
+ const handleSubmit = async (event: FormEvent) => {
+ event.preventDefault();
+ setErrorMessage("");
+
+ const trimmedEmail = email.trim();
+ const trimmedPassword = password.trim();
+ const trimmedName = name.trim();
+
+ if (!trimmedEmail || !trimmedPassword) {
+ setErrorMessage("Email and password are required.");
+ return;
+ }
+ if (mode === "signup" && !trimmedName) {
+ setErrorMessage("Name is required for signup.");
+ return;
+ }
try {
- // Replace with actual API call
- // const res = await fetch(`${API_URL}/auth/login`, ...);
-
- // MOCK RESPONSE for MVP testing
- await new Promise(r => setTimeout(r, 1000));
- if (email === "student@nst.edu" && password === "password") {
- login("mock-jwt-token-123", { id: "1", name: "Birajit Saikia", email });
- toast.success("Welcome back!");
+ if (mode === "login") {
+ await login({ email: trimmedEmail, password: trimmedPassword });
} else {
- throw new Error("Invalid credentials");
+ await signup({
+ name: trimmedName,
+ email: trimmedEmail,
+ password: trimmedPassword,
+ });
}
- } catch (err) {
- toast.error("Login failed. Check your credentials.");
- } finally {
- setIsLoading(false);
+ router.replace(redirectTo);
+ } catch (error) {
+ const message =
+ error instanceof Error ? error.message : "Unable to authenticate.";
+ setErrorMessage(message);
}
};
return (
-
-
-
-
Sign in to MLBoost
-
- Or create a new account
+
+
+
+
+
+
+
+ MLBoost
+
+
+ {mode === "login" ? "Sign in to continue" : "Create your account"}
+
+
+ Practice ML coding with instant feedback.
-
+
+ );
+}
+
+export default function LoginPage() {
+ return (
+
+ Loading authentication...
+
+ }
+ >
+
+
);
-}
\ No newline at end of file
+}
diff --git a/src/app/not-found.tsx b/src/app/not-found.tsx
new file mode 100644
index 0000000..8d92fcb
--- /dev/null
+++ b/src/app/not-found.tsx
@@ -0,0 +1,23 @@
+import Link from "next/link";
+
+export default function NotFoundPage() {
+ return (
+
+
+ 404
+
+
+ This page does not exist
+
+
+ The route may have moved or is unavailable.
+
+
+ Go to Problems
+
+
+ );
+}
diff --git a/src/app/page.tsx b/src/app/page.tsx
index 5aab8ea..18e5538 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -1,8 +1,6 @@
"use client";
-import { useState } from "react";
-import Sidebar from "./components/Sidebar";
-import Navbar from "./components/Navbar";
+import MainLayout from "./components/MainLayout";
import StatsCard from "./components/StatsCard";
import RecentActivity from "./components/RecentActivity";
import WeeklyGoals from "./components/WeeklyGoals";
@@ -45,155 +43,39 @@ const WEEKLY_GOALS = [
];
export default function Home() {
- const [isSidebarOpen, setIsSidebarOpen] = useState(true);
- const [selectedCategory, setSelectedCategory] = useState
("");
-
- const handleCategoryChange = (category: string) => {
- setSelectedCategory(category);
- };
-
- const handleLogout = () => {
- console.log("Logging out...");
- };
-
return (
-
-
setIsSidebarOpen(false)}
- />
-
- {!isSidebarOpen && (
-
- )}
-
-
-
-
-
-
-
- Welcome back, Alex
-
-
- Continue your AI/ML learning journey
-
-
-
-
-
- }
- />
-
-
-
- }
- />
-
-
-
- }
- />
-
-
-
- }
- />
-
+ Daily Focus
+
+
+ Keep the streak alive and solve 2 ML problems today
+
+
+ Interview-style challenges, instant feedback, and clean progress
+ tracking.
+
+
-
-
-
+
{error.message}
+
+
+
+
+
+ Loading problem arena...
+
+ );
+}
diff --git a/src/app/problems/[slug]/page.tsx b/src/app/problems/[slug]/page.tsx
index c399b4a..b4d3a48 100644
--- a/src/app/problems/[slug]/page.tsx
+++ b/src/app/problems/[slug]/page.tsx
@@ -1,221 +1,851 @@
"use client";
-import { useState, useEffect } from "react";
-import { useParams } from "next/navigation";
-import Editor from "@monaco-editor/react";
-import ReactMarkdown from "react-markdown"; // New dependency
-import { Toaster, toast } from "react-hot-toast"; // New dependency
-import Navbar from "../../components/Navbar";
-import Sidebar from "../../components/Sidebar";
-import { useAuth } from "@/context/AuthContext"; // Use global auth
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import dynamic from "next/dynamic";
+import { useParams, useRouter } from "next/navigation";
+import { Group, Panel, Separator } from "react-resizable-panels";
+import {
+ ArrowLeft,
+ ChevronRight,
+ Clock3,
+ Loader2,
+ Play,
+ RefreshCcw,
+ RotateCw,
+ SendHorizontal,
+} from "lucide-react";
import {
fetchProblemBySlug,
+ fetchSubmissionHistory,
+ runCode,
submitSolution,
- ProblemDetail,
- SubmissionResult,
} from "@/lib/api";
+import { trackEvent } from "@/lib/analytics";
+import { ProblemDetail, SubmissionRecord, SubmissionResult } from "@/types";
+import ThemeSwitcher from "@/app/components/ThemeSwitcher";
+
+const MonacoEditor = dynamic(
+ async () => (await import("@monaco-editor/react")).default,
+ {
+ ssr: false,
+ loading: () => (
+
+ Loading editor...
+
+ ),
+ }
+);
+
+function getDraftStorageKey(slug: string): string {
+ return `mlboost:draft:${slug}`;
+}
+
+function formatSubmissionDate(value: string): string {
+ const date = new Date(value);
+ return date.toLocaleString(undefined, {
+ month: "short",
+ day: "numeric",
+ hour: "2-digit",
+ minute: "2-digit",
+ });
+}
+
+function DifficultyBadge({ difficulty }: { difficulty: ProblemDetail["difficulty"] }) {
+ const classes =
+ difficulty === "Easy"
+ ? "bg-emerald-500/15 text-emerald-300 border-emerald-500/20"
+ : difficulty === "Medium"
+ ? "bg-amber-500/15 text-amber-300 border-amber-500/20"
+ : "bg-red-500/15 text-red-300 border-red-500/20";
+
+ return (
+
+ {difficulty}
+
+ );
+}
+
+function ResultView({ result }: { result: SubmissionResult | null }) {
+ if (!result) {
+ return (
+
+ No execution yet for this tab.
+
+ );
+ }
+
+ const positive = result.status === "Accepted";
+
+ return (
+
+
+
+ {result.status}
+
+
{result.message}
+
+ {result.mode === "run" ? "Sample" : "Hidden"} tests: {result.passedCount}/
+ {result.totalCount} | Runtime: {result.runtimeMs}ms | Memory: {result.memoryMb}MB
+
+ {result.source}
+
+
+
+
+ {result.traceback ? (
+
+ {result.traceback}
+
+ ) : null}
+
+
+ {result.testCases.map((testCase) => (
+
+
+ {testCase.name}: {testCase.passed ? "Passed" : "Failed"}
+
+ {testCase.input ? (
+ Input: {testCase.input}
+ ) : null}
+ {testCase.expectedOutput ? (
+
+ Expected: {testCase.expectedOutput}
+
+ ) : null}
+ {testCase.actualOutput ? (
+ Got: {testCase.actualOutput}
+ ) : null}
+ {testCase.errorMessage ? (
+ {testCase.errorMessage}
+ ) : null}
+
+ ))}
+
+
Loading Workspace...
;
+ if (isLoadingProblem) {
+ return (
+
+
+ Loading problem arena...
+
+ );
+ }
+
+ if (error || !problem) {
+ return (
+
+
+ {error ?? "Problem could not be loaded."}
+
+
+
-
-
setIsSidebarOpen(false)} />
-
-
-
-
-
- {/* Left Panel: Problem & Tabs */}
-
- {/* Tabs */}
-
-
-
+
+
+
+
+
+
{problem.title}
+
+
+ {problem.category}
+ {problem.companies?.length ? (
+
+ {problem.companies.slice(0, 2).join(", ")}
+
+ ) : null}
+
+
+
+
+
+
+
- {/* Content Area */}
-
- {activeTab === "description" ? (
+
+
+
+ setActivePane("problem")}
+ >
+
+
+
+
+
+
+ {activeLeftTab === "description" ? (
<>
-
-
{problem.title}
-
-
- {problem.difficulty}
-
-
-
+ Problem
+
+
+ {problem.description}
+
- {/* Markdown Rendered Description */}
-
- {problem.description || "No description provided."}
-
+ {problem.constraints.length > 0 ? (
+
+
+ Constraints
+
+
+ {problem.constraints.map((constraint) => (
+ -
+
+ {constraint}
+
+ ))}
+
+
-
- Example {idx + 1}
-
-
-
-
-
Output:
-
{tc.output}
+ {problem.examples.length > 0 ? (
+
+
+ Examples
+
+ {problem.examples.map((example, index) => (
+
+
+ Example {index + 1}
+
+
+
+ Input:
+ {example.input}
+
+
+ Output:
+ {example.output}
+
+ {example.explanation ? (
+
+ Explanation:
+ {example.explanation}
+
+ ) : null}
+
-
+ ))}
- ))}
+ ) : null}
- ) : (
-
-
No past submissions yet.
-
- )}
-
-
- {/* Editor Toolbar */}
-
-
- Python 3.10
-
-
-
+ {activeLeftTab === "editorial" ? (
+ isEditorialUnlocked ? (
+
+
+ Editorial
+
+
{problem.editorial.summary}
+
+ Approach
+
+
{problem.editorial.approach}
- {/* Monaco Editor */}
-
- setCode(value || "")}
- options={{
- minimap: { enabled: false },
- fontSize: 14,
- lineNumbers: "on",
- scrollBeyondLastLine: false,
- automaticLayout: true,
- padding: { top: 16 }
- }}
- />
-
-
- {/* Interactive Console */}
- {output && (
-
-
- Console Output
-
-
-
- {output.status === "Accepted" ? (
-
-
-
Runtime: {output.runtime}ms
+
+
+ Time Complexity
+ {problem.editorial.timeComplexity}
+
+
+ Space Complexity
+ {problem.editorial.spaceComplexity}
+
+
+
+ Common Pitfalls
+
+
+ {problem.editorial.pitfalls.map((pitfall) => (
+ -
+
+ {pitfall}
+
+ ))}
+
+
+ ) : (
+
+ Editorial unlocks after an Accepted{" "}
+ submission on hidden tests.
+
+ )
+ ) : null}
+
+ {activeLeftTab === "history" ? (
+
+
+ Submission History
+
+ {isLoadingHistory ? (
+
Loading history...
+ ) : history.length === 0 ? (
+
No runs yet for this problem.
) : (
-
- {output.errorMessage && (
-
- {output.errorMessage}
-
- )}
+ {history.map((entry) => (
+
+
+
+
+ {entry.mode === "run" ? "Run" : "Submit"}: {entry.result.status}
+
+
+
+ {formatSubmissionDate(entry.createdAt)}
+
+
+ {entry.result.passedCount}/{entry.result.totalCount} tests | Runtime {" "}
+ {entry.result.runtimeMs}ms
+
+
+
+
+
+
+
+ ))}
)}
-
- )}
-
-
-
+ main.py
+
+ Run: Ctrl/Cmd+Enter | Submit: Ctrl/Cmd+Shift+Enter | Focus panes: Alt+1/2/3
+
+
+ {
+ editorRef.current = editor;
+ }}
+ height="calc(100% - 2.5rem)"
+ language="python"
+ theme={editorTheme}
+ value={code}
+ onChange={(value) => setCode(value ?? "")}
+ options={{
+ minimap: { enabled: false },
+ lineNumbers: "on",
+ scrollBeyondLastLine: false,
+ fontSize: 14,
+ automaticLayout: true,
+ fontFamily:
+ "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace",
+ tabSize: 4,
+ padding: { top: 12 },
+ }}
+ />
+
+
+
+
+
+
+ setActivePane("console")}
+ >
+
+
+
+
+
+
+
);
-}
\ No newline at end of file
+}
diff --git a/src/app/problems/error.tsx b/src/app/problems/error.tsx
new file mode 100644
index 0000000..931db8c
--- /dev/null
+++ b/src/app/problems/error.tsx
@@ -0,0 +1,23 @@
+"use client";
+
+export default function ProblemsError({
+ error,
+ reset,
+}: {
+ error: Error;
+ reset: () => void;
+}) {
+ return (
+
+
+ Failed to load problems: {error.message}
+
+
+
+ );
+}
diff --git a/src/app/problems/loading.tsx b/src/app/problems/loading.tsx
new file mode 100644
index 0000000..4c78ef8
--- /dev/null
+++ b/src/app/problems/loading.tsx
@@ -0,0 +1,7 @@
+export default function ProblemsLoading() {
+ return (
+
+ Loading problems...
+
+ );
+}
diff --git a/src/app/problems/page.tsx b/src/app/problems/page.tsx
index 09bea8e..e75563b 100644
--- a/src/app/problems/page.tsx
+++ b/src/app/problems/page.tsx
@@ -1,131 +1,222 @@
"use client";
-import { useEffect, useState } from "react";
-import Link from "next/link";
-import Navbar from "../components/Navbar";
-import Sidebar from "../components/Sidebar";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import MainLayout from "../components/MainLayout";
+import ProblemsTable from "../components/ProblemsTable";
+import SearchBar from "../components/SearchBar";
+import { FilterState, Problem } from "@/types";
import { fetchProblems } from "@/lib/api";
-import { Problem } from "@/types";
-import { Search, Filter, CheckCircle, Circle } from "lucide-react";
export default function ProblemsPage() {
+ const router = useRouter();
+ const searchParams = useSearchParams();
const [problems, setProblems] = useState
([]);
- const [loading, setLoading] = useState(true);
- const [search, setSearch] = useState("");
- const [filterDifficulty, setFilterDifficulty] = useState("All");
+ const [isLoading, setIsLoading] = useState(true);
+ const [selectedCategory, setSelectedCategory] = useState("");
+ const [searchQuery, setSearchQuery] = useState("");
+ const searchInputRef = useRef(null);
+ const [filters, setFilters] = useState({
+ level: "All Levels",
+ category: "All Categories",
+ statusFilter: "all",
+ });
useEffect(() => {
- const loadData = async () => {
+ const load = async () => {
try {
+ setIsLoading(true);
const data = await fetchProblems();
setProblems(data);
- } catch (error) {
- console.error("Failed to load problems");
} finally {
- setLoading(false);
+ setIsLoading(false);
}
};
- loadData();
+
+ void load();
}, []);
- const filteredProblems = problems.filter((p) => {
- const matchesSearch = p.title.toLowerCase().includes(search.toLowerCase());
- const matchesDiff = filterDifficulty === "All" || p.difficulty === filterDifficulty;
- return matchesSearch && matchesDiff;
- });
+ useEffect(() => {
+ const categoryParam = searchParams.get("category");
+ const category = categoryParam?.trim() || "All Categories";
+ setSelectedCategory(category);
+ setFilters((current) => {
+ if (current.category === category) {
+ return current;
+ }
+ return { ...current, category };
+ });
+ }, [searchParams]);
+
+ useEffect(() => {
+ const handleShortcut = (event: KeyboardEvent) => {
+ const target = event.target as HTMLElement | null;
+ const isTextInput =
+ target?.tagName === "INPUT" ||
+ target?.tagName === "TEXTAREA" ||
+ target?.isContentEditable;
+
+ if (event.key === "/" && !isTextInput) {
+ event.preventDefault();
+ searchInputRef.current?.focus();
+ }
+ };
+
+ window.addEventListener("keydown", handleShortcut);
+ return () => {
+ window.removeEventListener("keydown", handleShortcut);
+ };
+ }, []);
+
+ const filteredProblems = useMemo(() => {
+ let list = [...problems];
+
+ if (filters.level !== "All Levels") {
+ list = list.filter((problem) => problem.difficulty === filters.level);
+ }
+ if (filters.category !== "All Categories") {
+ list = list.filter((problem) => problem.category === filters.category);
+ }
+ if (filters.statusFilter === "solved") {
+ list = list.filter((problem) => problem.status === "solved");
+ }
+ if (filters.statusFilter === "todo") {
+ list = list.filter((problem) => problem.status !== "solved");
+ }
+ if (searchQuery.trim()) {
+ const query = searchQuery.toLowerCase();
+ list = list.filter(
+ (problem) =>
+ problem.title.toLowerCase().includes(query) ||
+ problem.tags.some((tag) => tag.toLowerCase().includes(query)) ||
+ problem.category.toLowerCase().includes(query)
+ );
+ }
+
+ return list;
+ }, [problems, filters, searchQuery]);
+
+ const solvedCount = problems.filter((problem) => problem.status === "solved").length;
+ const mediumCount = problems.filter(
+ (problem) => problem.difficulty === "Medium"
+ ).length;
+
+ const headerSlot = (
+
+
+
+ Total Problems
+
+
+ {problems.length}
+
+
+
+
+ Solved
+
+
+ {solvedCount}
+
+
+
+
+ Medium Challenges
+
+
+ {mediumCount}
+
+
+
+ );
return (
-
-
{}} />
-
-
-
-
- {/* Header & Filters */}
-
-
-
Problem Library
-
Master ML algorithms through practice
-
-
-
-
-
- setSearch(e.target.value)}
- />
-
-
-
-
+
+
+
+
+
+
+
+
+
+ Shortcut: press / to focus search.
+
+
- {/* Problem List Table */}
-
-
-
Status
-
Title
-
Difficulty
-
Tags
-
-
- {loading ? (
-
Loading library...
- ) : filteredProblems.length === 0 ? (
-
No problems found.
- ) : (
-
- {filteredProblems.map((problem) => (
-
-
- {problem.status === "solved" ? (
-
- ) : (
-
- )}
-
-
- {problem.title}
-
-
-
- {problem.difficulty}
-
-
-
- {problem.tags.slice(0, 2).map(tag => (
-
- {tag}
-
- ))}
-
-
- ))}
-
- )}
+
+ {isLoading ? (
+
+ Loading problems...
-
-
+ Loading profile...
+
+ ) : (
+ <>
+
+
+ Solved
+ {profile.totalSolved}
+
+
+ Acceptance
+ {profile.acceptanceRate}%
+
+
+ Current Streak
+ {profile.streakDays} days
+
+
+ Recent Contest Rank
+ #{profile.recentContestRanks[0]?.rank ?? "-"}
+
+
+
+
+
+ Submission Heatmap
+
+
+
+ {heatmapWeeks.map((week, index) => (
+
+ {week.map((cell) => (
+
+ ))}
+
+ ))}
+
+
+ Solved by Topic
+
+
+ {profile.topicProgress.map((topic) => {
+ const pct = Math.round((topic.solved / topic.total) * 100);
+ return (
+
+
+ {topic.topic}
+ {topic.solved}/{topic.total}
+
+
+
+ );
+ })}
+
+ Acceptance Trend
+
+
+ {profile.acceptanceTrend.map((point) => (
+
+
+
{point.label.slice(5)}
+
{point.acceptance}%
+
+ ))}
+
+ Recent Contest Ranks
+
+
+
+
+
+ | Contest |
+ Rank |
+ Participants |
+ Score |
+ Date |
+
+
+
+ {profile.recentContestRanks.map((row) => (
+
+ | {row.contest} |
+ #{row.rank} |
+ {row.participants} |
+ {row.score} |
+ {row.date} |
+
+ ))}
+
+
+
+ Problems Solved This Week
+
+
+ {DAILY.map((item) => (
+
+
{item.day}
+
{item.value}
+
+ ))}
+
+ Streak Summary
+
+ 12 days
+
+ Best streak: 23 days
+
+
+
+
+
+
+ Topic Coverage
+
+
+ {AREAS.map((area) => {
+ const percent = Math.round((area.solved / area.total) * 100);
+ return (
+
+
+ {area.label}
+ {area.solved}/{area.total}
+
+
+
+ );
+ })}
+
+ Tracks
+
+
+ {tracks.length}
+
+
+
+
+ Solved in Tracks
+
+
+ {totals.solvedProblems}
+
+
+
+
+ Total Questions
+
+
+ {totals.totalProblems}
+
+
+
+ }
+ >
+ {isLoading ? (
+
+ Loading company tracks...
+
+ ) : (
+
+ {tracks.map((track) => {
+ const progress = Math.round((track.solvedProblems / track.totalProblems) * 100);
+ return (
+
+
+
+
+ {track.company}
+
+
+ {track.title}
+
+
+ {track.description}
+
+
+
+
+
+
+ {track.solvedProblems}/{track.totalProblems} solved
+
+ {progress}%
+
+
+
+ {track.tags.map((tag) => (
+
+ {tag}
+
+ ))}
+
+
+ );
+ })}
+
+ )}
+
+ );
+}
diff --git a/src/context/AuthContext.tsx b/src/context/AuthContext.tsx
index c4741f6..0e1cf71 100644
--- a/src/context/AuthContext.tsx
+++ b/src/context/AuthContext.tsx
@@ -1,70 +1,103 @@
"use client";
-import { createContext, useContext, useState, ReactNode } from "react";
-import { useRouter } from "next/navigation";
+import {
+ createContext,
+ useCallback,
+ useContext,
+ useEffect,
+ useMemo,
+ useState,
+} from "react";
+import { AuthSession, LoginPayload, SignupPayload, User } from "@/types";
+import {
+ getCurrentSession,
+ loginUser,
+ logoutUser,
+ signupUser,
+} from "@/lib/api";
-interface User {
- id: string;
- name: string;
- email: string;
-}
-
-interface AuthContextType {
+interface AuthContextValue {
user: User | null;
- token: string | null;
- login: (token: string, userData: User) => void;
- logout: () => void;
+ session: AuthSession | null;
+ isAuthenticated: boolean;
isLoading: boolean;
+ login: (payload: LoginPayload) => Promise;
+ signup: (payload: SignupPayload) => Promise;
+ logout: () => Promise;
+ refreshSession: () => Promise;
}
-const AuthContext = createContext(undefined);
+const AuthContext = createContext(null);
-export function AuthProvider({ children }: { children: ReactNode }) {
- const router = useRouter();
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+ const [session, setSession] = useState(null);
+ const [isLoading, setIsLoading] = useState(true);
- // ✅ Lazy initialization (runs only once)
- const [token, setToken] = useState(() => {
- if (typeof window !== "undefined") {
- return localStorage.getItem("accessToken");
+ const refreshSession = useCallback(async () => {
+ setIsLoading(true);
+ try {
+ const currentSession = await getCurrentSession();
+ setSession(currentSession);
+ } finally {
+ setIsLoading(false);
}
- return null;
- });
+ }, []);
- const [user, setUser] = useState(() => {
- if (typeof window !== "undefined") {
- const storedUser = localStorage.getItem("user");
- return storedUser ? JSON.parse(storedUser) : null;
- }
- return null;
- });
+ useEffect(() => {
+ void refreshSession();
+ }, [refreshSession]);
- const [isLoading] = useState(false); // no longer needed
+ const login = useCallback(async (payload: LoginPayload) => {
+ setIsLoading(true);
+ try {
+ const newSession = await loginUser(payload);
+ setSession(newSession);
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
- const login = (newToken: string, userData: User) => {
- localStorage.setItem("accessToken", newToken);
- localStorage.setItem("user", JSON.stringify(userData));
- setToken(newToken);
- setUser(userData);
- router.push("/");
- };
+ const signup = useCallback(async (payload: SignupPayload) => {
+ setIsLoading(true);
+ try {
+ const newSession = await signupUser(payload);
+ setSession(newSession);
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
- const logout = () => {
- localStorage.removeItem("accessToken");
- localStorage.removeItem("user");
- setToken(null);
- setUser(null);
- router.push("/login");
- };
+ const logout = useCallback(async () => {
+ setIsLoading(true);
+ try {
+ await logoutUser();
+ setSession(null);
+ } finally {
+ setIsLoading(false);
+ }
+ }, []);
- return (
-
- {children}
-
+ const value = useMemo(
+ () => ({
+ user: session?.user ?? null,
+ session,
+ isAuthenticated: Boolean(session?.accessToken),
+ isLoading,
+ login,
+ signup,
+ logout,
+ refreshSession,
+ }),
+ [session, isLoading, login, signup, logout, refreshSession]
);
+
+ return {children};
}
-export const useAuth = () => {
+export function useAuth(): AuthContextValue {
const context = useContext(AuthContext);
- if (!context) throw new Error("useAuth must be used within an AuthProvider");
+ if (!context) {
+ throw new Error("useAuth must be used within an AuthProvider.");
+ }
return context;
-};
+}
diff --git a/src/lib/analytics.ts b/src/lib/analytics.ts
new file mode 100644
index 0000000..4f99923
--- /dev/null
+++ b/src/lib/analytics.ts
@@ -0,0 +1,43 @@
+export interface AnalyticsEvent {
+ name: string;
+ payload?: Record;
+ timestamp?: string;
+}
+
+const ANALYTICS_ENDPOINT = process.env.NEXT_PUBLIC_ANALYTICS_ENDPOINT;
+
+function enrichEvent(event: AnalyticsEvent): AnalyticsEvent {
+ return {
+ ...event,
+ timestamp: event.timestamp ?? new Date().toISOString(),
+ };
+}
+
+export async function trackEvent(event: AnalyticsEvent): Promise {
+ const enriched = enrichEvent(event);
+
+ if (typeof window !== "undefined") {
+ const history = window.localStorage.getItem("mlboost.analytics.events");
+ const parsed = history ? (JSON.parse(history) as AnalyticsEvent[]) : [];
+ parsed.unshift(enriched);
+ window.localStorage.setItem(
+ "mlboost.analytics.events",
+ JSON.stringify(parsed.slice(0, 150))
+ );
+ }
+
+ if (!ANALYTICS_ENDPOINT) {
+ return;
+ }
+
+ try {
+ await fetch(ANALYTICS_ENDPOINT, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(enriched),
+ keepalive: true,
+ });
+ } catch {
+ // No-op for analytics failures.
+ }
+}
diff --git a/src/lib/api.test.ts b/src/lib/api.test.ts
new file mode 100644
index 0000000..1e95e22
--- /dev/null
+++ b/src/lib/api.test.ts
@@ -0,0 +1,60 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { getCurrentSession, loginUser, runCode, submitSolution } from "@/lib/api";
+
+describe("mock api", () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ window.localStorage.clear();
+ document.cookie = "mlboost_auth=; path=/; max-age=0";
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it("creates and restores a mock login session", async () => {
+ const loginPromise = loginUser({
+ email: "alice@example.com",
+ password: "secret123",
+ });
+
+ await vi.runAllTimersAsync();
+ const session = await loginPromise;
+
+ expect(session.user.email).toBe("alice@example.com");
+
+ const currentSessionPromise = getCurrentSession();
+ await vi.runAllTimersAsync();
+ const currentSession = await currentSessionPromise;
+
+ expect(currentSession?.accessToken).toBeTruthy();
+ expect(currentSession?.user.name).toBe("Alice");
+ });
+
+ it("returns accepted status for a strong run", async () => {
+ const runPromise = runCode(
+ "p-004",
+ `def binary_f1(y_true, y_pred):\n tp = 1\n precision = 1\n recall = 1\n return 1`
+ );
+
+ await vi.runAllTimersAsync();
+ const result = await runPromise;
+
+ expect(result.status).toBe("Accepted");
+ expect(result.testCases.length).toBeGreaterThan(0);
+ expect(result.testCases.every((testCase) => testCase.passed)).toBe(true);
+ });
+
+ it("returns failed status for placeholder submission", async () => {
+ const submitPromise = submitSolution(
+ "p-001",
+ `def fit_and_predict(X_train, y_train, X_test, k):\n pass`
+ );
+
+ await vi.runAllTimersAsync();
+ const result = await submitPromise;
+
+ expect(result.status).toBe("Failed");
+ expect(result.score).toBeLessThan(100);
+ });
+});
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 755338d..e5abe8b 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -1,112 +1,1384 @@
-import { Problem } from "@/types";
+import {
+ AuthSession,
+ CompanyTrack,
+ ContestRank,
+ ExecutionMode,
+ LoginPayload,
+ Problem,
+ ProblemDetail,
+ SignupPayload,
+ SubmissionRecord,
+ SubmissionResult,
+ SubmissionTestCaseResult,
+ TopicProgressPoint,
+ UserProfile,
+} from "@/types";
+import { AUTH_COOKIE_NAME, AUTH_COOKIE_TTL_SECONDS } from "@/lib/auth";
+import { trackEvent } from "@/lib/analytics";
+import { reportError, reportMessage } from "@/lib/observability";
-// Update to match your backend port (5001)
-const API_BASE_URL =
- process.env.NEXT_PUBLIC_API_URL || "http://localhost:5001/api";
+type ApiMode = "mock" | "live" | "auto";
-// Shape of the problem list response from the backend
-interface ProblemApiResponse {
- _id: string;
- slug: string;
- title: string;
- difficulty: Problem["difficulty"];
- tags?: string[];
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:5001/api";
+const API_MODE = ((process.env.NEXT_PUBLIC_API_MODE || "mock").toLowerCase() ||
+ "mock") as ApiMode;
+const API_RETRY_COUNT = Number(process.env.NEXT_PUBLIC_API_RETRY_COUNT || 2);
+const API_TIMEOUT_MS = Number(process.env.NEXT_PUBLIC_API_TIMEOUT_MS || 8000);
+const ALLOW_MOCK_FALLBACK = process.env.NEXT_PUBLIC_API_FALLBACK_TO_MOCK !== "false";
+
+const MOCK_SESSION_KEY = "mlboost.mock.session";
+const ACCESS_TOKEN_KEY = "accessToken";
+const SUBMISSION_HISTORY_KEY = "mlboost.submission.history";
+
+const SUBMIT_DELAY_MS = 2000;
+const FETCH_DELAY_MS = 420;
+const AUTH_DELAY_MS = 550;
+
+interface EvaluationRule {
+ requiredPatterns: RegExp[];
+ guidance: string;
}
-// Shape of a sample test case in the problem detail
-export interface SampleTestCase {
- input: string;
- output: string;
- explanation?: string;
+const MOCK_COMPANY_TRACKS: CompanyTrack[] = [
+ {
+ id: "track-ml-core-50",
+ title: "ML Engineer Core 50",
+ company: "Meta",
+ description:
+ "A focused set of 50 modeling + feature engineering problems for ML interviews.",
+ totalProblems: 50,
+ solvedProblems: 19,
+ tags: ["modeling", "metrics", "feature-engineering"],
+ },
+ {
+ id: "track-pandas-interview-30",
+ title: "Pandas Interview 30",
+ company: "Uber",
+ description:
+ "Table transform and aggregation patterns commonly asked in data interviews.",
+ totalProblems: 30,
+ solvedProblems: 11,
+ tags: ["pandas", "joins", "groupby"],
+ },
+ {
+ id: "track-recommendation-20",
+ title: "Recommendation Systems 20",
+ company: "Netflix",
+ description:
+ "Ranking, retrieval, and evaluation exercises for recommender workflows.",
+ totalProblems: 20,
+ solvedProblems: 4,
+ tags: ["ranking", "retrieval", "offline-metrics"],
+ },
+];
+
+const MOCK_RECENT_RANKS: ContestRank[] = [
+ {
+ contest: "Model Metrics Sprint",
+ rank: 182,
+ participants: 4820,
+ score: 1780,
+ date: "2026-02-24",
+ },
+ {
+ contest: "Feature Engineering Weekly",
+ rank: 96,
+ participants: 3910,
+ score: 1860,
+ date: "2026-02-17",
+ },
+ {
+ contest: "Data Prep Rapid Round",
+ rank: 121,
+ participants: 4055,
+ score: 1814,
+ date: "2026-02-10",
+ },
+];
+
+const MOCK_PROBLEMS: ProblemDetail[] = [
+ {
+ id: "p-001",
+ slug: "knn-classifier-iris",
+ title: "KNN Classifier on Iris",
+ difficulty: "Easy",
+ category: "Supervised Learning",
+ acceptance: 74,
+ acceptanceRate: 74,
+ status: "unsolved",
+ tags: ["scikit-learn", "classification", "knn"],
+ companies: ["Meta", "Amazon", "DoorDash"],
+ trackIds: ["track-ml-core-50"],
+ summary: "Implement KNN and return deterministic predictions on Iris slices.",
+ description:
+ "Implement `fit_and_predict(X_train, y_train, X_test, k)` using K-Nearest Neighbors logic. Use Euclidean distance and majority voting. Do not use `KNeighborsClassifier`.",
+ constraints: [
+ "1 <= k <= len(X_train)",
+ "All features are numeric floats.",
+ "Return a list of integer class predictions.",
+ ],
+ examples: [
+ {
+ input:
+ "X_train=[[5.1,3.5],[4.9,3.0]], y_train=[0,0], X_test=[[5.0,3.4]], k=1",
+ output: "[0]",
+ },
+ {
+ input:
+ "X_train=[[6.7,3.1],[6.3,2.9],[5.0,3.6]], y_train=[2,1,0], X_test=[[6.5,3.0]], k=3",
+ output: "[1]",
+ },
+ ],
+ sampleTestCases: [
+ {
+ input:
+ "X_train=[[5.1,3.5],[4.9,3.0]], y_train=[0,0], X_test=[[5.0,3.4]], k=1",
+ output: "[0]",
+ },
+ {
+ input:
+ "X_train=[[6.7,3.1],[6.3,2.9],[5.0,3.6]], y_train=[2,1,0], X_test=[[6.5,3.0]], k=3",
+ output: "[1]",
+ },
+ {
+ input:
+ "X_train=[[5.4,3.9],[6.1,2.8],[6.9,3.1]], y_train=[0,1,2], X_test=[[6.0,3.0]], k=1",
+ output: "[1]",
+ },
+ ],
+ hiddenTestCount: 6,
+ hints: [
+ "Compute distances for every test point against every train point.",
+ "Sort by distance and pick the first k neighbors.",
+ "Vote with class frequency; break ties by choosing the smallest label.",
+ ],
+ editorial: {
+ summary:
+ "Use a brute-force nearest neighbor search over all training points and stable tie-breaking.",
+ approach:
+ "For each test vector, compute Euclidean distances to every train vector, sort ascending, take top-k labels, and vote by frequency with deterministic tie breaks.",
+ timeComplexity: "O(n_test * n_train * d + n_test * n_train log n_train)",
+ spaceComplexity: "O(n_train)",
+ pitfalls: [
+ "Using Manhattan distance instead of Euclidean by mistake.",
+ "Not handling label ties deterministically.",
+ "Mutating input arrays during sorting.",
+ ],
+ },
+ starterCode: `import math
+from collections import Counter
+
+def fit_and_predict(X_train, y_train, X_test, k):
+ predictions = []
+ for x in X_test:
+ distances = []
+ for i, train_x in enumerate(X_train):
+ distance = math.sqrt(sum((a - b) ** 2 for a, b in zip(x, train_x)))
+ distances.append((distance, y_train[i]))
+
+ distances.sort(key=lambda item: item[0])
+ top_k = [label for _, label in distances[:k]]
+ vote = Counter(top_k).most_common()
+ vote.sort(key=lambda pair: (-pair[1], pair[0]))
+ predictions.append(vote[0][0])
+ return predictions`,
+ },
+ {
+ id: "p-002",
+ slug: "linear-regression-gradient-descent",
+ title: "Linear Regression via Gradient Descent",
+ difficulty: "Medium",
+ category: "Supervised Learning",
+ acceptance: 61,
+ acceptanceRate: 61,
+ status: "attempted",
+ tags: ["numpy", "regression", "optimization"],
+ companies: ["Google", "Stripe", "Databricks"],
+ trackIds: ["track-ml-core-50"],
+ summary:
+ "Train y = wx + b with gradient descent and return learned parameters.",
+ description:
+ "Implement `train_linear_regression(X, y, lr, epochs)` and return `(w, b)`. Optimize Mean Squared Error with gradient descent.",
+ constraints: [
+ "X and y are 1D lists of equal length.",
+ "Use full-batch gradient descent.",
+ "Return floats rounded to 4 decimals.",
+ ],
+ examples: [
+ {
+ input: "X=[1,2,3], y=[3,5,7], lr=0.01, epochs=1000",
+ output: "(2.0, 1.0)",
+ },
+ ],
+ sampleTestCases: [
+ {
+ input: "X=[1,2,3], y=[3,5,7], lr=0.01, epochs=1000",
+ output: "(2.0, 1.0)",
+ },
+ {
+ input: "X=[0,1,2], y=[1,3,5], lr=0.02, epochs=800",
+ output: "(2.0, 1.0)",
+ },
+ {
+ input: "X=[2,4,6], y=[5,9,13], lr=0.01, epochs=1200",
+ output: "(2.0, 1.0)",
+ },
+ ],
+ hiddenTestCount: 7,
+ hints: [
+ "Prediction: y_hat = w*x + b.",
+ "dw = (2/n) * sum((y_hat - y) * x); db = (2/n) * sum(y_hat - y).",
+ "Update both parameters each epoch.",
+ ],
+ editorial: {
+ summary:
+ "Batch gradient descent converges quickly on 1D linear relations if updates are consistent.",
+ approach:
+ "Initialize w, b to 0. In each epoch compute predictions, derive gradients over all samples, and update both parameters using learning rate.",
+ timeComplexity: "O(epochs * n)",
+ spaceComplexity: "O(n)",
+ pitfalls: [
+ "Forgetting factor 2 in MSE gradient.",
+ "Updating w before computing db from same step.",
+ "Choosing an unstable learning rate.",
+ ],
+ },
+ starterCode: `def train_linear_regression(X, y, lr=0.01, epochs=1000):
+ n = len(X)
+ w = 0.0
+ b = 0.0
+
+ for _ in range(epochs):
+ y_hat = [w * x + b for x in X]
+ dw = (2 / n) * sum((pred - target) * x for pred, target, x in zip(y_hat, y, X))
+ db = (2 / n) * sum(pred - target for pred, target in zip(y_hat, y))
+ w -= lr * dw
+ b -= lr * db
+
+ return round(w, 4), round(b, 4)`,
+ },
+ {
+ id: "p-003",
+ slug: "standardize-dataset",
+ title: "Standardize Dataset Columns",
+ difficulty: "Easy",
+ category: "Data Preprocessing",
+ acceptance: 82,
+ acceptanceRate: 82,
+ status: "solved",
+ tags: ["pandas", "numpy", "preprocessing"],
+ companies: ["Uber", "Airbnb", "Flipkart"],
+ trackIds: ["track-pandas-interview-30"],
+ summary: "Apply z-score standardization to selected numeric columns.",
+ description:
+ "Given a pandas DataFrame and a list of columns, return a new DataFrame where those columns are standardized using (x - mean) / std.",
+ constraints: [
+ "Do not mutate the input DataFrame.",
+ "Use population standard deviation (ddof=0).",
+ "Return values rounded to 5 decimals.",
+ ],
+ examples: [
+ {
+ input: "df={'age':[20,30,40]}, columns=['age']",
+ output: "age=[-1.22474, 0.0, 1.22474]",
+ },
+ ],
+ sampleTestCases: [
+ {
+ input: "df={'age':[20,30,40]}, columns=['age']",
+ output: "age=[-1.22474, 0.0, 1.22474]",
+ },
+ {
+ input: "df={'a':[1,2,3], 'b':[10,10,10]}, columns=['a']",
+ output: "a=[-1.22474, 0.0, 1.22474]",
+ },
+ {
+ input: "df={'x':[2,4,6,8]}, columns=['x']",
+ output: "x=[-1.34164,-0.44721,0.44721,1.34164]",
+ },
+ ],
+ hiddenTestCount: 5,
+ hints: [
+ "Work on a copy: `scaled = df.copy()`.",
+ "Use vectorized operations for each column.",
+ "Handle zero std by filling that column with 0.0.",
+ ],
+ editorial: {
+ summary:
+ "Standardization should be stable, non-mutating, and safe on constant columns.",
+ approach:
+ "Copy input frame, loop over target columns, compute mean/std (ddof=0), handle std=0 edge case, and write standardized values.",
+ timeComplexity: "O(n * c)",
+ spaceComplexity: "O(n * c)",
+ pitfalls: [
+ "Mutating original DataFrame.",
+ "Using sample std (ddof=1) accidentally.",
+ "Divide by zero for constant columns.",
+ ],
+ },
+ starterCode: `import pandas as pd
+
+def standardize_columns(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
+ scaled = df.copy()
+ for col in columns:
+ mean = scaled[col].mean()
+ std = scaled[col].std(ddof=0)
+ if std == 0:
+ scaled[col] = 0.0
+ else:
+ scaled[col] = ((scaled[col] - mean) / std).round(5)
+ return scaled`,
+ },
+ {
+ id: "p-004",
+ slug: "f1-score-from-scratch",
+ title: "Compute F1 Score from Scratch",
+ difficulty: "Medium",
+ category: "Model Evaluation",
+ acceptance: 58,
+ acceptanceRate: 58,
+ status: "unsolved",
+ tags: ["metrics", "classification", "scikit-learn"],
+ companies: ["Netflix", "Grab", "Microsoft"],
+ trackIds: ["track-ml-core-50", "track-recommendation-20"],
+ summary: "Implement precision, recall, and F1 for binary classification.",
+ description:
+ "Implement `binary_f1(y_true, y_pred)` returning a float in [0, 1]. Treat label `1` as positive class.",
+ constraints: [
+ "y_true and y_pred have equal lengths.",
+ "Handle divide-by-zero safely.",
+ "Round output to 4 decimals.",
+ ],
+ examples: [
+ {
+ input: "y_true=[1,0,1,1], y_pred=[1,0,0,1]",
+ output: "0.8",
+ },
+ ],
+ sampleTestCases: [
+ {
+ input: "y_true=[1,0,1,1], y_pred=[1,0,0,1]",
+ output: "0.8",
+ },
+ {
+ input: "y_true=[0,0,0], y_pred=[0,0,0]",
+ output: "0.0",
+ },
+ {
+ input: "y_true=[1,1,1], y_pred=[1,1,1]",
+ output: "1.0",
+ },
+ ],
+ hiddenTestCount: 8,
+ hints: [
+ "Count TP, FP, FN explicitly.",
+ "precision = TP / (TP + FP), recall = TP / (TP + FN).",
+ "F1 is 0 when precision + recall is 0.",
+ ],
+ editorial: {
+ summary:
+ "F1 balances precision and recall and is useful for imbalanced positives.",
+ approach:
+ "Compute TP/FP/FN in one pass, derive precision and recall with safe denominators, then harmonic mean.",
+ timeComplexity: "O(n)",
+ spaceComplexity: "O(1)",
+ pitfalls: [
+ "Using macro formula on binary labels incorrectly.",
+ "Not guarding denominator = 0.",
+ "Mixing positive class label.",
+ ],
+ },
+ starterCode: `def binary_f1(y_true, y_pred):
+ tp = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 1)
+ fp = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 1)
+ fn = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 0)
+
+ precision = tp / (tp + fp) if (tp + fp) else 0.0
+ recall = tp / (tp + fn) if (tp + fn) else 0.0
+
+ if precision + recall == 0:
+ return 0.0
+ return round(2 * precision * recall / (precision + recall), 4)`,
+ },
+];
+
+const EVALUATION_RULES: Record = {
+ "p-001": {
+ requiredPatterns: [
+ /def\s+fit_and_predict\s*\(/,
+ /distance/i,
+ /sort\(/,
+ /Counter|most_common/,
+ ],
+ guidance:
+ "Ensure you compute Euclidean distances and majority vote across the nearest neighbors.",
+ },
+ "p-002": {
+ requiredPatterns: [
+ /def\s+train_linear_regression\s*\(/,
+ /dw\s*=/,
+ /db\s*=/,
+ /for\s+_\s+in\s+range\(epochs\)/,
+ ],
+ guidance:
+ "Your loop should update both w and b every epoch using gradients from MSE.",
+ },
+ "p-003": {
+ requiredPatterns: [
+ /def\s+standardize_columns\s*\(/,
+ /copy\(/,
+ /std\(/,
+ /mean\(/,
+ ],
+ guidance:
+ "Work on a DataFrame copy and standardize each requested column with z-score.",
+ },
+ "p-004": {
+ requiredPatterns: [
+ /def\s+binary_f1\s*\(/,
+ /precision\s*=/,
+ /recall\s*=/,
+ /tp|true[_\s]?positive/i,
+ ],
+ guidance:
+ "Compute TP/FP/FN first, then precision and recall before calculating F1.",
+ },
+};
+
+function wait(ms: number): Promise {
+ return new Promise((resolve) => setTimeout(resolve, ms));
}
-// Full problem detail returned by GET /problems/:slug
-export interface ProblemDetail {
- _id: string;
- slug: string;
- title: string;
- difficulty: Problem["difficulty"];
- tags?: string[];
- description?: string;
- sampleTestCases?: SampleTestCase[];
+function clone(value: T): T {
+ return JSON.parse(JSON.stringify(value)) as T;
}
-// Result returned by /submissions
-export interface SubmissionResult {
- status: string;
- runtime?: number;
- errorMessage?: string;
- // allow extra fields without using `any`
- [key: string]: unknown;
+function isBrowser(): boolean {
+ return typeof window !== "undefined";
}
-export async function fetchProblems(): Promise {
+function getNormalizedApiMode(): ApiMode {
+ if (API_MODE === "mock" || API_MODE === "live" || API_MODE === "auto") {
+ return API_MODE;
+ }
+ return "mock";
+}
+
+export function getBackendMode(): ApiMode {
+ return getNormalizedApiMode();
+}
+
+function persistSession(session: AuthSession): void {
+ if (!isBrowser()) {
+ return;
+ }
+ window.localStorage.setItem(MOCK_SESSION_KEY, JSON.stringify(session));
+ window.localStorage.setItem(ACCESS_TOKEN_KEY, session.accessToken);
+ window.document.cookie = `${AUTH_COOKIE_NAME}=1; path=/; max-age=${AUTH_COOKIE_TTL_SECONDS}; samesite=lax`;
+}
+
+function readStoredSession(): AuthSession | null {
+ if (!isBrowser()) {
+ return null;
+ }
+ const hasAuthCookie = window.document.cookie
+ .split(";")
+ .some((part) => part.trim().startsWith(`${AUTH_COOKIE_NAME}=`));
+
+ if (!hasAuthCookie) {
+ window.localStorage.removeItem(MOCK_SESSION_KEY);
+ window.localStorage.removeItem(ACCESS_TOKEN_KEY);
+ return null;
+ }
+
+ const raw = window.localStorage.getItem(MOCK_SESSION_KEY);
+ if (!raw) {
+ return null;
+ }
+
try {
- const response = await fetch(`${API_BASE_URL}/problems`, {
- method: "GET",
- headers: {
- "Content-Type": "application/json",
- // Add Authorization header if you implement protected problem lists later
- },
- });
+ return JSON.parse(raw) as AuthSession;
+ } catch {
+ window.localStorage.removeItem(MOCK_SESSION_KEY);
+ return null;
+ }
+}
+
+function clearStoredSession(): void {
+ if (!isBrowser()) {
+ return;
+ }
+ window.localStorage.removeItem(MOCK_SESSION_KEY);
+ window.localStorage.removeItem(ACCESS_TOKEN_KEY);
+ window.document.cookie = `${AUTH_COOKIE_NAME}=; path=/; max-age=0; samesite=lax`;
+}
+
+function createMockSession(name: string, email: string): AuthSession {
+ const now = new Date();
+ const token = `mock_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+
+ return {
+ user: {
+ id: `user_${email.toLowerCase().replace(/[^a-z0-9]/g, "")}`,
+ name,
+ email: email.toLowerCase(),
+ avatarUrl: "",
+ createdAt: now.toISOString(),
+ },
+ accessToken: token,
+ expiresAt: new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+ };
+}
+
+function getProblemByIdentifier(identifier: string): ProblemDetail | undefined {
+ return MOCK_PROBLEMS.find(
+ (problem) => problem.id === identifier || problem.slug === identifier
+ );
+}
- if (!response.ok) {
- throw new Error("Failed to fetch problems");
+function getRule(problemId: string): EvaluationRule {
+ return (
+ EVALUATION_RULES[problemId] ?? {
+ requiredPatterns: [/def\s+\w+\s*\(/],
+ guidance: "Define a function and return deterministic output.",
}
+ );
+}
- const data: ProblemApiResponse[] = await response.json();
-
- // Map Backend Data (MongoDB _id) to Frontend Interface
- return data.map((item: ProblemApiResponse): Problem => ({
- id: item._id, // Map _id to id
- slug: item.slug, // Important for routing
- title: item.title,
- difficulty: item.difficulty,
- // Fallback for fields not yet in backend
- category: item.tags?.[0] || "General",
- acceptance: 0, // Backend doesn't calculate this yet
- status: "unsolved", // Needs user-specific fetch
- tags: item.tags || [],
- }));
- } catch (error) {
- console.error("Error fetching problems:", error);
+function readSubmissionHistoryStore(): SubmissionRecord[] {
+ if (!isBrowser()) {
+ return [];
+ }
+
+ const raw = window.localStorage.getItem(SUBMISSION_HISTORY_KEY);
+ if (!raw) {
return [];
}
+
+ try {
+ const parsed = JSON.parse(raw) as SubmissionRecord[];
+ return Array.isArray(parsed) ? parsed : [];
+ } catch {
+ window.localStorage.removeItem(SUBMISSION_HISTORY_KEY);
+ return [];
+ }
+}
+
+function writeSubmissionHistoryStore(records: SubmissionRecord[]): void {
+ if (!isBrowser()) {
+ return;
+ }
+
+ window.localStorage.setItem(
+ SUBMISSION_HISTORY_KEY,
+ JSON.stringify(records.slice(0, 180))
+ );
+}
+
+function upsertSubmissionRecord(record: SubmissionRecord): void {
+ const history = readSubmissionHistoryStore();
+ history.unshift(record);
+ writeSubmissionHistoryStore(history);
+}
+
+function computeDynamicStatus(
+ problemId: string,
+ fallback: Problem["status"]
+): Problem["status"] {
+ const history = readSubmissionHistoryStore();
+ const forProblem = history.filter((entry) => entry.problemId === problemId);
+
+ if (forProblem.some((entry) => entry.mode === "submit" && entry.result.status === "Accepted")) {
+ return "solved";
+ }
+
+ if (forProblem.length > 0) {
+ return "attempted";
+ }
+
+ return fallback;
+}
+
+function normalizeToListItem(problem: ProblemDetail): Problem {
+ return {
+ id: problem.id,
+ slug: problem.slug,
+ title: problem.title,
+ difficulty: problem.difficulty,
+ category: problem.category,
+ acceptance: problem.acceptance,
+ acceptanceRate: problem.acceptanceRate,
+ status: computeDynamicStatus(problem.id, problem.status),
+ tags: [...problem.tags],
+ summary: problem.summary,
+ companies: problem.companies,
+ trackIds: problem.trackIds,
+ };
+}
+
+function makeSampleOrHiddenCases(
+ mode: ExecutionMode,
+ problem: ProblemDetail
+): Array<{ input: string; output: string }> {
+ if (mode === "run") {
+ return problem.sampleTestCases.slice(0, 2);
+ }
+
+ return Array.from({ length: problem.hiddenTestCount }).map((_, index) => ({
+ input: `hidden-${index + 1}`,
+ output: "hidden-output",
+ }));
+}
+
+function buildTestCaseResult(
+ mode: ExecutionMode,
+ index: number,
+ test: { input: string; output: string },
+ passed: boolean,
+ guidance: string,
+ runtimeTriggered: boolean
+): SubmissionTestCaseResult {
+ const visibility = mode === "run" ? "sample" : "hidden";
+
+ if (runtimeTriggered) {
+ return {
+ name: visibility === "sample" ? `Sample ${index + 1}` : `Hidden ${index + 1}`,
+ visibility,
+ passed: false,
+ errorMessage: "Execution terminated unexpectedly.",
+ input: visibility === "sample" ? test.input : undefined,
+ expectedOutput: visibility === "sample" ? test.output : undefined,
+ actualOutput: visibility === "sample" ? "" : undefined,
+ };
+ }
+
+ if (visibility === "sample") {
+ return {
+ name: `Sample ${index + 1}`,
+ visibility,
+ input: test.input,
+ expectedOutput: test.output,
+ actualOutput: passed ? test.output : "Incorrect output",
+ passed,
+ errorMessage: passed ? undefined : guidance,
+ };
+ }
+
+ return {
+ name: `Hidden ${index + 1}`,
+ visibility,
+ passed,
+ errorMessage: passed ? undefined : guidance,
+ };
+}
+
+function createSubmissionResult(
+ problemId: string,
+ code: string,
+ mode: ExecutionMode,
+ source: "mock" | "live" = "mock"
+): SubmissionResult {
+ const problem = getProblemByIdentifier(problemId);
+
+ if (!problem) {
+ return {
+ submissionId: `sub_${Date.now()}`,
+ problemId,
+ mode,
+ visibility: mode === "run" ? "sample" : "hidden",
+ status: "Runtime Error",
+ runtimeMs: 0,
+ memoryMb: 0,
+ score: 0,
+ passedCount: 0,
+ totalCount: 0,
+ message: "Problem not found.",
+ traceback: "LookupError: The requested problem could not be loaded.",
+ testCases: [],
+ source,
+ submittedAt: new Date().toISOString(),
+ };
+ }
+
+ const cleanedCode = code.trim();
+ const rule = getRule(problem.id);
+ const hasPlaceholder = /\bpass\b/.test(cleanedCode) || cleanedCode.length < 25;
+ const runtimeTriggered =
+ /1\s*\/\s*0/.test(cleanedCode) || /raise\s+[A-Za-z_]\w*Error/.test(cleanedCode);
+ const matchedPatterns = rule.requiredPatterns.filter((pattern) =>
+ pattern.test(cleanedCode)
+ ).length;
+
+ const isStrongSolution =
+ !hasPlaceholder && matchedPatterns === rule.requiredPatterns.length;
+ const isPartialSolution =
+ !hasPlaceholder &&
+ matchedPatterns >= Math.max(1, Math.ceil(rule.requiredPatterns.length * 0.5));
+
+ const cases = makeSampleOrHiddenCases(mode, problem);
+
+ const testCases = cases.map((testCase, index) => {
+ let passed = false;
+
+ if (runtimeTriggered) {
+ passed = false;
+ } else if (isStrongSolution) {
+ passed = true;
+ } else if (isPartialSolution && index === 0) {
+ passed = true;
+ }
+
+ return buildTestCaseResult(
+ mode,
+ index,
+ testCase,
+ passed,
+ rule.guidance,
+ runtimeTriggered
+ );
+ });
+
+ const passedCount = testCases.filter((testCase) => testCase.passed).length;
+ const totalCount = testCases.length;
+ const score = Math.round((passedCount / Math.max(1, totalCount)) * 100);
+ const runtimeMs = runtimeTriggered ? 0 : 42 + Math.floor(Math.random() * 190);
+ const memoryMb = runtimeTriggered ? 0 : 14 + Math.floor(Math.random() * 36);
+
+ if (runtimeTriggered) {
+ return {
+ submissionId: `sub_${Date.now()}`,
+ problemId: problem.id,
+ mode,
+ visibility: mode === "run" ? "sample" : "hidden",
+ status: "Runtime Error",
+ runtimeMs,
+ memoryMb,
+ score: 0,
+ passedCount: 0,
+ totalCount,
+ message: "Runtime error while executing your solution.",
+ traceback:
+ "Traceback (most recent call last):\n File \"main.py\", line 1, in \nRuntimeError: simulated execution failure",
+ testCases,
+ source,
+ submittedAt: new Date().toISOString(),
+ };
+ }
+
+ if (passedCount === totalCount) {
+ return {
+ submissionId: `sub_${Date.now()}`,
+ problemId: problem.id,
+ mode,
+ visibility: mode === "run" ? "sample" : "hidden",
+ status: "Accepted",
+ runtimeMs,
+ memoryMb,
+ score: 100,
+ passedCount,
+ totalCount,
+ message:
+ mode === "run"
+ ? "All sample test cases passed."
+ : "Accepted on hidden tests.",
+ testCases,
+ source,
+ submittedAt: new Date().toISOString(),
+ };
+ }
+
+ return {
+ submissionId: `sub_${Date.now()}`,
+ problemId: problem.id,
+ mode,
+ visibility: mode === "run" ? "sample" : "hidden",
+ status: "Failed",
+ runtimeMs,
+ memoryMb,
+ score,
+ passedCount,
+ totalCount,
+ message: `Passed ${passedCount}/${totalCount} ${
+ mode === "run" ? "sample" : "hidden"
+ } tests. ${rule.guidance}`,
+ testCases,
+ source,
+ submittedAt: new Date().toISOString(),
+ };
+}
+
+function createSubmissionRecord(
+ problemId: string,
+ code: string,
+ mode: ExecutionMode,
+ result: SubmissionResult
+): SubmissionRecord {
+ const problem = getProblemByIdentifier(problemId);
+
+ return {
+ id: result.submissionId,
+ problemId,
+ problemSlug: problem?.slug || problemId,
+ problemTitle: problem?.title || "Unknown Problem",
+ code,
+ mode,
+ result,
+ createdAt: result.submittedAt,
+ };
+}
+
+function parseJsonSafely(text: string): T {
+ return JSON.parse(text) as T;
+}
+
+async function fetchWithRetry(
+ path: string,
+ init?: RequestInit,
+ retries = API_RETRY_COUNT
+): Promise {
+ let attempt = 0;
+ let lastError: unknown;
+
+ while (attempt <= retries) {
+ const controller = new AbortController();
+ const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+
+ try {
+ const response = await fetch(`${API_BASE_URL}${path}`, {
+ ...init,
+ signal: controller.signal,
+ headers: {
+ "Content-Type": "application/json",
+ ...(init?.headers || {}),
+ },
+ });
+
+ clearTimeout(timeoutId);
+
+ if (!response.ok) {
+ const message = await response.text();
+ throw new Error(`HTTP ${response.status}: ${message || "Request failed"}`);
+ }
+
+ const text = await response.text();
+ return text ? parseJsonSafely(text) : ({} as T);
+ } catch (error) {
+ clearTimeout(timeoutId);
+ lastError = error;
+ attempt += 1;
+ if (attempt <= retries) {
+ await wait(250 * attempt);
+ }
+ }
+ }
+
+ throw lastError instanceof Error ? lastError : new Error("Request failed");
}
-export async function fetchProblemBySlug(
- slug: string
-): Promise {
+async function runWithBackendSwitch(
+ operation: string,
+ liveExecutor: () => Promise,
+ mockExecutor: () => Promise
+): Promise {
+ const mode = getNormalizedApiMode();
+
+ if (mode === "mock") {
+ return mockExecutor();
+ }
+
try {
- const response = await fetch(`${API_BASE_URL}/problems/${slug}`, {
- method: "GET",
- headers: { "Content-Type": "application/json" },
+ const response = await liveExecutor();
+ void trackEvent({ name: "api_live_success", payload: { operation } });
+ return response;
+ } catch (error) {
+ reportError(error, { operation, mode });
+
+ if (mode === "live" && !ALLOW_MOCK_FALLBACK) {
+ throw error instanceof Error ? error : new Error("Live API request failed");
+ }
+
+ reportMessage("Falling back to mock API", { operation, mode });
+ void trackEvent({ name: "api_live_fallback", payload: { operation, mode } });
+
+ return mockExecutor();
+ }
+}
+
+function toAuthSessionFromLive(
+ payload: unknown,
+ fallbackName: string,
+ fallbackEmail: string
+): AuthSession {
+ const parsed = (payload || {}) as {
+ token?: string;
+ accessToken?: string;
+ expiresAt?: string;
+ user?: Partial;
+ };
+
+ const token = parsed.accessToken || parsed.token || `live_${Date.now()}`;
+ const now = new Date();
+
+ return {
+ user: {
+ id: parsed.user?.id || `user_${fallbackEmail.replace(/[^a-z0-9]/gi, "")}`,
+ name: parsed.user?.name || fallbackName,
+ email: parsed.user?.email || fallbackEmail,
+ avatarUrl: parsed.user?.avatarUrl || "",
+ createdAt: parsed.user?.createdAt || now.toISOString(),
+ },
+ accessToken: token,
+ expiresAt:
+ parsed.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+ };
+}
+
+function toProblemFromLive(payload: unknown): Problem {
+ const parsed = payload as Partial & { _id?: string };
+ return {
+ id: parsed.id || parsed._id || `p-live-${Math.random().toString(36).slice(2, 8)}`,
+ slug: parsed.slug,
+ title: parsed.title || "Untitled Problem",
+ difficulty: parsed.difficulty || "Medium",
+ category: parsed.category || "General",
+ acceptance: parsed.acceptance || parsed.acceptanceRate || 0,
+ acceptanceRate: parsed.acceptanceRate || parsed.acceptance || 0,
+ status: parsed.status || "unsolved",
+ tags: parsed.tags || [],
+ summary: parsed.summary,
+ companies: parsed.companies,
+ trackIds: parsed.trackIds,
+ };
+}
+
+function toProblemDetailFromLive(slug: string, payload: unknown): ProblemDetail {
+ const base = toProblemFromLive(payload);
+ const parsed = payload as Partial;
+
+ return {
+ ...base,
+ slug: parsed.slug || slug,
+ description: parsed.description || "Problem description is unavailable.",
+ constraints: parsed.constraints || [],
+ examples: parsed.examples || [],
+ hints: parsed.hints || [],
+ sampleTestCases: parsed.sampleTestCases || parsed.examples || [],
+ hiddenTestCount: parsed.hiddenTestCount || 0,
+ editorial:
+ parsed.editorial ||
+ ({
+ summary: "Editorial unavailable.",
+ approach: "Connect the backend editorial endpoint to populate this section.",
+ timeComplexity: "N/A",
+ spaceComplexity: "N/A",
+ pitfalls: [],
+ } as ProblemDetail["editorial"]),
+ starterCode: parsed.starterCode || "def solve():\n pass",
+ };
+}
+
+function normalizeLiveSubmission(
+ problemId: string,
+ mode: ExecutionMode,
+ payload: unknown
+): SubmissionResult {
+ const parsed = payload as Partial & {
+ status?: SubmissionResult["status"] | string;
+ };
+
+ const testCases: SubmissionTestCaseResult[] = (parsed.testCases || []).map((item) => ({
+ name: item.name || "Case",
+ visibility: item.visibility || (mode === "run" ? "sample" : "hidden"),
+ input: item.input,
+ expectedOutput: item.expectedOutput,
+ actualOutput: item.actualOutput,
+ passed: Boolean(item.passed),
+ errorMessage: item.errorMessage,
+ }));
+
+ const totalCount = parsed.totalCount ?? testCases.length;
+ const passedCount =
+ parsed.passedCount ?? testCases.filter((testCase) => testCase.passed).length;
+
+ return {
+ submissionId: parsed.submissionId || `sub_live_${Date.now()}`,
+ problemId,
+ mode,
+ visibility: parsed.visibility || (mode === "run" ? "sample" : "hidden"),
+ status:
+ parsed.status === "Accepted" ||
+ parsed.status === "Failed" ||
+ parsed.status === "Runtime Error"
+ ? parsed.status
+ : "Failed",
+ runtimeMs: parsed.runtimeMs ?? 0,
+ memoryMb: parsed.memoryMb ?? 0,
+ score: parsed.score ?? Math.round((passedCount / Math.max(1, totalCount)) * 100),
+ message: parsed.message || "Execution completed.",
+ passedCount,
+ totalCount,
+ traceback: parsed.traceback,
+ testCases,
+ source: "live",
+ submittedAt: parsed.submittedAt || new Date().toISOString(),
+ };
+}
+
+function mockFetchProblems(): Problem[] {
+ return clone(MOCK_PROBLEMS.map(normalizeToListItem));
+}
+
+function mockFetchProblemBySlug(slug: string): ProblemDetail {
+ const problem = MOCK_PROBLEMS.find((item) => item.slug === slug);
+ if (!problem) {
+ throw new Error(`Problem with slug "${slug}" was not found.`);
+ }
+ return clone(problem);
+}
+
+async function liveFetchProblems(): Promise {
+ const data = await fetchWithRetry("/problems", { method: "GET" });
+ return data.map((entry) => toProblemFromLive(entry));
+}
+
+async function liveFetchProblemBySlug(slug: string): Promise {
+ const data = await fetchWithRetry(`/problems/${slug}`, { method: "GET" });
+ return toProblemDetailFromLive(slug, data);
+}
+
+async function mockExecute(problemId: string, code: string, mode: ExecutionMode) {
+ await wait(mode === "submit" ? SUBMIT_DELAY_MS : 900);
+ return createSubmissionResult(problemId, code, mode, "mock");
+}
+
+async function liveExecute(problemId: string, code: string, mode: ExecutionMode) {
+ const endpoint = mode === "run" ? "/submissions/run" : "/submissions";
+ const data = await fetchWithRetry(endpoint, {
+ method: "POST",
+ body: JSON.stringify({
+ problemId,
+ code,
+ language: "python",
+ languageId: 71,
+ mode,
+ }),
+ });
+
+ return normalizeLiveSubmission(problemId, mode, data);
+}
+
+async function persistExecutionRecord(
+ problemId: string,
+ code: string,
+ mode: ExecutionMode,
+ result: SubmissionResult
+): Promise {
+ const record = createSubmissionRecord(problemId, code, mode, result);
+ upsertSubmissionRecord(record);
+
+ void trackEvent({
+ name: mode === "run" ? "code_run" : "code_submit",
+ payload: {
+ problemId,
+ problemSlug: record.problemSlug,
+ result: result.status,
+ passedCount: result.passedCount,
+ totalCount: result.totalCount,
+ source: result.source,
+ },
+ });
+}
+
+function buildHeatmap(history: SubmissionRecord[]) {
+ const today = new Date();
+ const data: UserProfile["heatmap"] = [];
+
+ for (let i = 119; i >= 0; i -= 1) {
+ const date = new Date(today);
+ date.setDate(today.getDate() - i);
+ const key = date.toISOString().slice(0, 10);
+ const count = history.filter((entry) => entry.createdAt.slice(0, 10) === key).length;
+ data.push({ date: key, count });
+ }
+
+ return data;
+}
+
+function buildAcceptanceTrend(history: SubmissionRecord[]) {
+ const monthMap = new Map();
+
+ history.forEach((entry) => {
+ const month = entry.createdAt.slice(0, 7);
+ const existing = monthMap.get(month) || { accepted: 0, total: 0 };
+ existing.total += 1;
+ if (entry.result.status === "Accepted") {
+ existing.accepted += 1;
+ }
+ monthMap.set(month, existing);
+ });
+
+ return Array.from(monthMap.entries())
+ .sort(([a], [b]) => (a > b ? 1 : -1))
+ .slice(-6)
+ .map(([label, value]) => ({
+ label,
+ acceptance:
+ value.total === 0 ? 0 : Math.round((value.accepted / value.total) * 100),
+ }));
+}
+
+function buildTopicProgress(history: SubmissionRecord[]): TopicProgressPoint[] {
+ const solvedByProblem = new Set(
+ history
+ .filter((entry) => entry.mode === "submit" && entry.result.status === "Accepted")
+ .map((entry) => entry.problemId)
+ );
+
+ const topicTotals = new Map();
+
+ MOCK_PROBLEMS.forEach((problem) => {
+ const existing = topicTotals.get(problem.category) || { solved: 0, total: 0 };
+ existing.total += 1;
+ if (solvedByProblem.has(problem.id)) {
+ existing.solved += 1;
+ }
+ topicTotals.set(problem.category, existing);
+ });
+
+ return Array.from(topicTotals.entries()).map(([topic, data]) => ({
+ topic,
+ solved: data.solved,
+ total: data.total,
+ }));
+}
+
+async function mockFetchUserProfile(): Promise {
+ const session = readStoredSession();
+ const history = readSubmissionHistoryStore();
+ const submits = history.filter((entry) => entry.mode === "submit");
+ const accepted = submits.filter((entry) => entry.result.status === "Accepted");
+
+ const fallbackUser = session?.user || {
+ id: "user_guest",
+ name: "Learner",
+ email: "learner@example.com",
+ avatarUrl: "",
+ createdAt: new Date().toISOString(),
+ };
+
+ return {
+ user: fallbackUser,
+ totalSolved: new Set(accepted.map((entry) => entry.problemId)).size,
+ acceptanceRate:
+ submits.length === 0
+ ? 0
+ : Math.round((accepted.length / Math.max(1, submits.length)) * 100),
+ streakDays: 12,
+ heatmap: buildHeatmap(history),
+ acceptanceTrend: buildAcceptanceTrend(history),
+ topicProgress: buildTopicProgress(history),
+ recentContestRanks: clone(MOCK_RECENT_RANKS),
+ };
+}
+
+async function liveFetchUserProfile(): Promise {
+ const data = await fetchWithRetry>("/profile/me", {
+ method: "GET",
+ });
+
+ const fallback = await mockFetchUserProfile();
+
+ return {
+ user: data.user || fallback.user,
+ totalSolved: data.totalSolved ?? fallback.totalSolved,
+ acceptanceRate: data.acceptanceRate ?? fallback.acceptanceRate,
+ streakDays: data.streakDays ?? fallback.streakDays,
+ heatmap: data.heatmap || fallback.heatmap,
+ acceptanceTrend: data.acceptanceTrend || fallback.acceptanceTrend,
+ topicProgress: data.topicProgress || fallback.topicProgress,
+ recentContestRanks: data.recentContestRanks || fallback.recentContestRanks,
+ };
+}
+
+async function mockFetchCompanyTracks(): Promise {
+ return clone(MOCK_COMPANY_TRACKS);
+}
+
+async function liveFetchCompanyTracks(): Promise {
+ const data = await fetchWithRetry("/tracks", { method: "GET" });
+ return data;
+}
+
+export async function loginUser(payload: LoginPayload): Promise {
+ const email = payload.email.trim().toLowerCase();
+ const password = payload.password.trim();
+
+ if (!email || !password) {
+ throw new Error("Email and password are required.");
+ }
+
+ const guessedName = email.split("@")[0] || "Learner";
+ const name = guessedName
+ .split(/[.\-_]/g)
+ .filter(Boolean)
+ .map((chunk) => chunk.charAt(0).toUpperCase() + chunk.slice(1))
+ .join(" ");
+
+ const mockExecutor = async () => {
+ await wait(AUTH_DELAY_MS);
+ return createMockSession(name || "Learner", email);
+ };
+
+ const liveExecutor = async () => {
+ const response = await fetchWithRetry("/auth/login", {
+ method: "POST",
+ body: JSON.stringify({ email, password }),
});
- if (!response.ok) throw new Error("Failed to fetch problem");
- const problem: ProblemDetail = await response.json();
- return problem;
- } catch (error) {
- console.error("Error fetching problem:", error);
- throw error;
+ return toAuthSessionFromLive(response, name || "Learner", email);
+ };
+
+ const session = await runWithBackendSwitch("login", liveExecutor, mockExecutor);
+ persistSession(session);
+ void trackEvent({ name: "auth_login", payload: { mode: getNormalizedApiMode() } });
+ return clone(session);
+}
+
+export async function signupUser(payload: SignupPayload): Promise {
+ const email = payload.email.trim().toLowerCase();
+ const password = payload.password.trim();
+ const name = payload.name.trim();
+
+ if (!name || !email || !password) {
+ throw new Error("Name, email, and password are required.");
}
+
+ const mockExecutor = async () => {
+ await wait(AUTH_DELAY_MS);
+ return createMockSession(name, email);
+ };
+
+ const liveExecutor = async () => {
+ const response = await fetchWithRetry("/auth/signup", {
+ method: "POST",
+ body: JSON.stringify({ email, password, name }),
+ });
+ return toAuthSessionFromLive(response, name, email);
+ };
+
+ const session = await runWithBackendSwitch("signup", liveExecutor, mockExecutor);
+ persistSession(session);
+ void trackEvent({ name: "auth_signup", payload: { mode: getNormalizedApiMode() } });
+ return clone(session);
+}
+
+export async function getCurrentSession(): Promise {
+ await wait(120);
+ return clone(readStoredSession());
+}
+
+export async function logoutUser(): Promise {
+ await wait(90);
+ clearStoredSession();
+ void trackEvent({ name: "auth_logout" });
+}
+
+export async function fetchProblems(): Promise {
+ const mockExecutor = async () => {
+ await wait(FETCH_DELAY_MS);
+ return mockFetchProblems();
+ };
+
+ const liveExecutor = async () => {
+ const data = await liveFetchProblems();
+ return data;
+ };
+
+ return runWithBackendSwitch("fetch_problems", liveExecutor, mockExecutor);
+}
+
+export async function fetchProblemBySlug(slug: string): Promise {
+ const mockExecutor = async () => {
+ await wait(FETCH_DELAY_MS + 100);
+ return mockFetchProblemBySlug(slug);
+ };
+
+ const liveExecutor = async () => liveFetchProblemBySlug(slug);
+
+ return runWithBackendSwitch("fetch_problem_detail", liveExecutor, mockExecutor);
+}
+
+export async function runCode(
+ problemId: string,
+ code: string,
+ _problemSlug?: string,
+ _problemTitle?: string
+): Promise {
+ void _problemSlug;
+ void _problemTitle;
+
+ const mockExecutor = async () => mockExecute(problemId, code, "run");
+ const liveExecutor = async () => liveExecute(problemId, code, "run");
+
+ const result = await runWithBackendSwitch("run_code", liveExecutor, mockExecutor);
+ await persistExecutionRecord(problemId, code, "run", result);
+ return result;
}
export async function submitSolution(
problemId: string,
code: string,
- languageId: number,
- token: string
+ _languageId = 71,
+ _token?: string,
+ _problemSlug?: string,
+ _problemTitle?: string
): Promise {
- const response = await fetch(`${API_BASE_URL}/submissions`, {
- method: "POST",
- headers: {
- "Content-Type": "application/json",
- Authorization: `Bearer ${token}`, // Secure submission
- },
- body: JSON.stringify({ problemId, code, languageId }),
- });
+ void _languageId;
+ void _token;
+ void _problemSlug;
+ void _problemTitle;
+
+ const mockExecutor = async () => mockExecute(problemId, code, "submit");
+ const liveExecutor = async () => liveExecute(problemId, code, "submit");
- const result: SubmissionResult = await response.json();
+ const result = await runWithBackendSwitch("submit_code", liveExecutor, mockExecutor);
+ await persistExecutionRecord(problemId, code, "submit", result);
return result;
}
+
+export async function fetchSubmissionHistory(
+ problemIdentifier: string
+): Promise {
+ await wait(120);
+ const problem = getProblemByIdentifier(problemIdentifier);
+ const slug = problem?.slug || problemIdentifier;
+
+ return clone(
+ readSubmissionHistoryStore()
+ .filter((entry) => entry.problemSlug === slug || entry.problemId === problemIdentifier)
+ .sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1))
+ );
+}
+
+export async function fetchCompanyTracks(): Promise {
+ return runWithBackendSwitch(
+ "fetch_company_tracks",
+ () => liveFetchCompanyTracks(),
+ () => mockFetchCompanyTracks()
+ );
+}
+
+export async function fetchUserProfile(): Promise {
+ return runWithBackendSwitch(
+ "fetch_user_profile",
+ () => liveFetchUserProfile(),
+ () => mockFetchUserProfile()
+ );
+}
+
+export async function clearSubmissionHistory(): Promise {
+ if (!isBrowser()) {
+ return;
+ }
+ window.localStorage.removeItem(SUBMISSION_HISTORY_KEY);
+}
diff --git a/src/lib/auth.ts b/src/lib/auth.ts
new file mode 100644
index 0000000..0ced4b4
--- /dev/null
+++ b/src/lib/auth.ts
@@ -0,0 +1,2 @@
+export const AUTH_COOKIE_NAME = "mlboost_auth";
+export const AUTH_COOKIE_TTL_SECONDS = 7 * 24 * 60 * 60;
diff --git a/src/lib/observability.ts b/src/lib/observability.ts
new file mode 100644
index 0000000..f3f316f
--- /dev/null
+++ b/src/lib/observability.ts
@@ -0,0 +1,24 @@
+import * as Sentry from "@sentry/nextjs";
+
+export function reportError(error: unknown, context?: Record) {
+ const normalizedError =
+ error instanceof Error ? error : new Error(String(error));
+
+ Sentry.captureException(normalizedError, {
+ extra: context,
+ });
+
+ if (process.env.NODE_ENV !== "production") {
+ console.error("[observability]", normalizedError, context);
+ }
+}
+
+export function reportMessage(
+ message: string,
+ context?: Record
+) {
+ Sentry.captureMessage(message, {
+ level: "info",
+ extra: context,
+ });
+}
diff --git a/src/test/setup.ts b/src/test/setup.ts
new file mode 100644
index 0000000..fcef802
--- /dev/null
+++ b/src/test/setup.ts
@@ -0,0 +1,32 @@
+import { cleanup } from "@testing-library/react";
+import "@testing-library/jest-dom/vitest";
+import { afterEach, vi } from "vitest";
+
+afterEach(() => {
+ cleanup();
+});
+
+Object.defineProperty(window, "matchMedia", {
+ writable: true,
+ value: vi.fn().mockImplementation((query: string) => ({
+ matches: false,
+ media: query,
+ onchange: null,
+ addListener: vi.fn(),
+ removeListener: vi.fn(),
+ addEventListener: vi.fn(),
+ removeEventListener: vi.fn(),
+ dispatchEvent: vi.fn(),
+ })),
+});
+
+class ResizeObserverMock {
+ observe() {}
+ unobserve() {}
+ disconnect() {}
+}
+
+Object.defineProperty(window, "ResizeObserver", {
+ writable: true,
+ value: ResizeObserverMock,
+});
diff --git a/src/types/index.ts b/src/types/index.ts
index cedd3c9..d7eac33 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -1,16 +1,174 @@
+export type Difficulty = "Easy" | "Medium" | "Hard";
+
+export type ProblemStatus = "solved" | "attempted" | "unsolved";
+
+export type SubmissionVerdict = "Accepted" | "Failed" | "Runtime Error";
+
+export type ExecutionMode = "run" | "submit";
+
+export type TestCaseVisibility = "sample" | "hidden";
+
+export interface ProblemExample {
+ input: string;
+ output: string;
+ explanation?: string;
+}
+
export interface Problem {
id: string;
- slug?: string; // Added for routing
+ slug?: string;
title: string;
- difficulty: "Easy" | "Medium" | "Hard";
+ difficulty: Difficulty;
category: string;
acceptance: number;
- status: "solved" | "attempted" | "unsolved";
+ acceptanceRate: number;
+ status: ProblemStatus;
+ tags: string[];
+ summary?: string;
+ description?: string;
+ constraints?: string[];
+ examples?: ProblemExample[];
+ hints?: string[];
+ starterCode?: string;
+ companies?: string[];
+ trackIds?: string[];
+}
+
+export interface ProblemEditorial {
+ summary: string;
+ approach: string;
+ timeComplexity: string;
+ spaceComplexity: string;
+ pitfalls: string[];
+}
+
+export interface ProblemDetail extends Problem {
+ slug: string;
+ description: string;
+ constraints: string[];
+ examples: ProblemExample[];
+ hints: string[];
+ starterCode: string;
+ sampleTestCases: ProblemExample[];
+ hiddenTestCount: number;
+ editorial: ProblemEditorial;
+}
+
+export interface User {
+ id: string;
+ name: string;
+ email: string;
+ avatarUrl?: string;
+ createdAt: string;
+}
+
+export interface AuthSession {
+ user: User;
+ accessToken: string;
+ expiresAt: string;
+}
+
+export interface LoginPayload {
+ email: string;
+ password: string;
+}
+
+export interface SignupPayload extends LoginPayload {
+ name: string;
+}
+
+export interface SubmissionTestCaseResult {
+ name: string;
+ visibility: TestCaseVisibility;
+ input?: string;
+ expectedOutput?: string;
+ actualOutput?: string;
+ passed: boolean;
+ errorMessage?: string;
+}
+
+export interface SubmissionResult {
+ submissionId: string;
+ problemId: string;
+ status: SubmissionVerdict;
+ runtimeMs: number;
+ memoryMb: number;
+ score: number;
+ message: string;
+ mode: ExecutionMode;
+ visibility: TestCaseVisibility;
+ passedCount: number;
+ totalCount: number;
+ traceback?: string;
+ testCases: SubmissionTestCaseResult[];
+ source: "mock" | "live";
+ submittedAt: string;
+}
+
+export interface CodeExecutionPayload {
+ problemId: string;
+ code: string;
+ language: "python";
+}
+
+export interface SubmissionRecord {
+ id: string;
+ problemId: string;
+ problemSlug: string;
+ problemTitle: string;
+ code: string;
+ mode: ExecutionMode;
+ result: SubmissionResult;
+ createdAt: string;
+}
+
+export interface CompanyTrack {
+ id: string;
+ title: string;
+ company: string;
+ description: string;
+ totalProblems: number;
+ solvedProblems: number;
tags: string[];
}
+export interface HeatmapCell {
+ date: string;
+ count: number;
+}
+
+export interface AcceptanceTrendPoint {
+ label: string;
+ acceptance: number;
+}
+
+export interface TopicProgressPoint {
+ topic: string;
+ solved: number;
+ total: number;
+}
+
+export interface ContestRank {
+ contest: string;
+ rank: number;
+ participants: number;
+ score: number;
+ date: string;
+}
+
+export interface UserProfile {
+ user: User;
+ totalSolved: number;
+ acceptanceRate: number;
+ streakDays: number;
+ heatmap: HeatmapCell[];
+ acceptanceTrend: AcceptanceTrendPoint[];
+ topicProgress: TopicProgressPoint[];
+ recentContestRanks: ContestRank[];
+}
+
export interface FilterState {
level: string;
category: string;
statusFilter: "all" | "todo" | "solved";
-}
\ No newline at end of file
+}
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..2c63493
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,16 @@
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+ test: {
+ environment: "jsdom",
+ globals: true,
+ setupFiles: ["./src/test/setup.ts"],
+ include: ["src/**/*.test.{ts,tsx}"],
+ },
+ resolve: {
+ alias: {
+ "@": path.resolve(__dirname, "./src"),
+ },
+ },
+});