feat: add comprehensive unit tests for priority 1 components

- Set up Vitest testing infrastructure with React support
- Add unit tests for useAssistantSettings hook with localStorage handling
- Add unit tests for github.ts utility functions (URL building, API fetching)
- Add unit tests for utils.ts cn function (className merging)
- Add unit tests for chat API route with provider selection
- Add unit tests for docs-tree API route with file system operations
- Fixed all failing tests and linting issues
- All 69 tests now pass successfully

Test coverage includes happy paths, edge cases, and error handling scenarios.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: SiYG

CLAUDE.md

@@ -0,0 +1,135 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Common Development Commands
+
+### Installation and Setup
+
+```bash
+# Install dependencies using pnpm (recommended)
+pnpm install
+
+# Or using npm
+npm install
+```
+
+### Development
+
+```bash
+# Start development server on http://localhost:3000
+pnpm dev
+
+# Build the project
+pnpm build
+
+# Start production server
+pnpm start
+
+# Process MDX files (runs automatically after install)
+pnpm postinstall
+```
+
+### Code Quality
+
+```bash
+# Run linting
+pnpm lint
+
+# Run type checking
+pnpm typecheck
+
+# Check image compliance with project rules
+pnpm lint:images
+
+# Migrate images to proper directory structure
+pnpm migrate:images
+```
+
+### Git Commits
+
+- The project uses Husky for git hooks and lint-staged for pre-commit formatting
+- Prettier will automatically format files on commit
+- On Windows + VSCode/Cursor, use command line (`git commit`) instead of GUI to avoid Husky bugs
+
+## Project Architecture
+
+### Tech Stack
+
+- **Framework**: Next.js 15 with App Router
+- **Documentation**: Fumadocs MDX (文档系统)
+- **Styling**: Tailwind CSS v4
+- **UI Components**: Fumadocs UI + custom components
+- **Authentication**: NextAuth (beta)
+- **AI Integration**: Vercel AI SDK with Assistant UI
+- **Database**: Prisma with Neon (PostgreSQL)
+
+### Directory Structure
+
+```
+app/
+├── api/           # API routes (auth, chat, docs-tree)
+├── components/    # React components
+│   ├── assistant-ui/  # AI assistant components
+│   └── ui/           # Reusable UI components
+├── docs/          # MDX documentation content
+│   ├── ai/        # AI-related documentation
+│   ├── computer-science/  # CS topics
+│   ├── frontend/  # Frontend development
+│   └── [...slug]/ # Dynamic routing for docs
+├── hooks/         # Custom React hooks
+└── layout.tsx     # Root layout with providers
+```
+
+### Documentation Structure
+
+- Uses "Folder as a Book" pattern - each folder can have an `index.mdx` for overview
+- URLs are auto-generated from file structure (e.g., `docs/ai/llm-basics/index.mdx` → `/ai/llm-basics`)
+- File naming: use `kebab-case` and numeric prefixes for ordering (e.g., `01-intro.mdx`)
+- Numeric prefixes are stripped from final URLs
+
+### Image Management
+
+- Images should be placed in `./<basename>.assets/` directory alongside the MDX file
+- Example: `foo.mdx` → images go in `./foo.assets/`
+- Auto-migration scripts handle image placement during commits
+- Site-wide images: `/images/site/*`
+- Component demos: `/images/components/<name>/*`
+
+### MDX Frontmatter
+
+Required fields:
+
+```yaml
+---
+title: Document Title
+---
+```
+
+Optional fields:
+
+```yaml
+---
+description: Brief description
+date: "2025-01-01"
+tags:
+  - tag1
+  - tag2
+---
+```
+
+### Key Features
+
+1. **AI Assistant**: Integrated chat interface with support for multiple AI providers
+2. **Internationalization**: Using next-intl for multi-language support
+3. **Search**: Orama search integration for documentation
+4. **Comments**: Giscus integration for discussion
+5. **Math Support**: KaTeX for mathematical expressions
+6. **Authentication**: GitHub OAuth integration
+
+### Development Considerations
+
+- The project uses Fumadocs for documentation, refer to [Fumadocs docs](https://fumadocs.dev/docs) for UI components
+- Math expressions use remark-math and rehype-katex plugins
+- Authentication is handled via NextAuth with Neon database adapter
+- The project includes pre-configured GitHub Actions for automated deployment

app/api/chat/route.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { POST } from "./route";
+import { streamText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+
+// Mock the AI SDKs
+vi.mock("@ai-sdk/openai", () => ({
+  createOpenAI: vi.fn(),
+}));
+
+vi.mock("@ai-sdk/google", () => ({
+  createGoogleGenerativeAI: vi.fn(),
+}));
+
+vi.mock("ai", () => ({
+  streamText: vi.fn(),
+  convertToModelMessages: vi.fn((messages) => messages),
+  UIMessage: {},
+}));
+
+describe("chat API route", () => {
+  const mockStreamText = vi.mocked(streamText);
+  const mockCreateOpenAI = vi.mocked(createOpenAI);
+  const mockCreateGoogleGenerativeAI = vi.mocked(createGoogleGenerativeAI);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should return error when API key is missing", async () => {
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Hello" }],
+        provider: "openai",
+      }),
+    });
+
+    const response = await POST(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toBe(
+      "API key is required. Please configure your API key in the settings.",
+    );
+  });
+
+  it("should return error when API key is empty string", async () => {
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Hello" }],
+        provider: "openai",
+        apiKey: "   ",
+      }),
+    });
+
+    const response = await POST(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.error).toBe(
+      "API key is required. Please configure your API key in the settings.",
+    );
+  });
+
+  it("should use OpenAI provider by default", async () => {
+    const mockModel = vi.fn();
+    const mockOpenAIInstance = vi.fn(() => mockModel);
+    mockCreateOpenAI.mockReturnValue(mockOpenAIInstance);
+
+    const mockStreamResponse = {
+      toUIMessageStreamResponse: vi.fn(() => new Response()),
+    };
+    mockStreamText.mockReturnValue(mockStreamResponse);
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Hello" }],
+        apiKey: "test-api-key",
+      }),
+    });
+
+    await POST(request);
+
+    expect(mockCreateOpenAI).toHaveBeenCalledWith({
+      apiKey: "test-api-key",
+    });
+    expect(mockOpenAIInstance).toHaveBeenCalledWith("gpt-4.1-nano");
+    expect(mockStreamText).toHaveBeenCalledWith({
+      model: mockModel,
+      system: expect.stringContaining("You are a helpful AI assistant"),
+      messages: [{ role: "user", content: "Hello" }],
+    });
+  });
+
+  it("should use Gemini provider when specified", async () => {
+    const mockModel = vi.fn();
+    const mockGeminiInstance = vi.fn(() => mockModel);
+    mockCreateGoogleGenerativeAI.mockReturnValue(mockGeminiInstance);
+
+    const mockStreamResponse = {
+      toUIMessageStreamResponse: vi.fn(() => new Response()),
+    };
+    mockStreamText.mockReturnValue(mockStreamResponse);
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Hello" }],
+        provider: "gemini",
+        apiKey: "test-gemini-key",
+      }),
+    });
+
+    await POST(request);
+
+    expect(mockCreateGoogleGenerativeAI).toHaveBeenCalledWith({
+      apiKey: "test-gemini-key",
+    });
+    expect(mockGeminiInstance).toHaveBeenCalledWith("models/gemini-2.0-flash");
+  });
+
+  it("should include page context in system message", async () => {
+    const mockModel = vi.fn();
+    const mockOpenAIInstance = vi.fn(() => mockModel);
+    mockCreateOpenAI.mockReturnValue(mockOpenAIInstance);
+
+    const mockStreamResponse = {
+      toUIMessageStreamResponse: vi.fn(() => new Response()),
+    };
+    mockStreamText.mockReturnValue(mockStreamResponse);
+
+    const pageContext = {
+      title: "Test Page",
+      description: "Test Description",
+      content: "Page content here",
+      slug: "test-page",
+    };
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Tell me about this page" }],
+        apiKey: "test-api-key",
+        pageContext,
+      }),
+    });
+
+    await POST(request);
+
+    expect(mockStreamText).toHaveBeenCalledWith({
+      model: expect.anything(),
+      system: expect.stringContaining("Page Title: Test Page"),
+      messages: expect.anything(),
+    });
+
+    const systemMessage = mockStreamText.mock.calls[0][0].system;
+    expect(systemMessage).toContain("Page Description: Test Description");
+    expect(systemMessage).toContain("Page URL: /docs/test-page");
+    expect(systemMessage).toContain("Page Content:\nPage content here");
+  });
+
+  it("should use custom system message when provided", async () => {
+    const mockModel = vi.fn();
+    const mockOpenAIInstance = vi.fn(() => mockModel);
+    mockCreateOpenAI.mockReturnValue(mockOpenAIInstance);
+
+    const mockStreamResponse = {
+      toUIMessageStreamResponse: vi.fn(() => new Response()),
+    };
+    mockStreamText.mockReturnValue(mockStreamResponse);
+
+    const customSystem = "You are a specialized assistant for coding tasks.";
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Help me code" }],
+        apiKey: "test-api-key",
+        system: customSystem,
+      }),
+    });
+
+    await POST(request);
+
+    expect(mockStreamText).toHaveBeenCalledWith({
+      model: expect.anything(),
+      system: customSystem,
+      messages: expect.anything(),
+    });
+  });
+
+  it("should handle API errors gracefully", async () => {
+    const mockOpenAIInstance = vi.fn(() => {
+      throw new Error("API Error");
+    });
+    mockCreateOpenAI.mockReturnValue(mockOpenAIInstance);
+
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Hello" }],
+        apiKey: "test-api-key",
+      }),
+    });
+
+    const response = await POST(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(500);
+    expect(data.error).toBe("Failed to process chat request");
+    expect(consoleSpy).toHaveBeenCalledWith(
+      "Chat API error:",
+      expect.any(Error),
+    );
+
+    consoleSpy.mockRestore();
+  });
+
+  it("should handle partial page context", async () => {
+    const mockModel = vi.fn();
+    const mockOpenAIInstance = vi.fn(() => mockModel);
+    mockCreateOpenAI.mockReturnValue(mockOpenAIInstance);
+
+    const mockStreamResponse = {
+      toUIMessageStreamResponse: vi.fn(() => new Response()),
+    };
+    mockStreamText.mockReturnValue(mockStreamResponse);
+
+    const pageContext = {
+      title: "Test Page",
+      content: "Page content here",
+      // Missing description and slug
+    };
+
+    const request = new Request("http://localhost:3000/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        messages: [{ role: "user", content: "Tell me about this page" }],
+        apiKey: "test-api-key",
+        pageContext,
+      }),
+    });
+
+    await POST(request);
+
+    const systemMessage = mockStreamText.mock.calls[0][0].system;
+    expect(systemMessage).toContain("Page Title: Test Page");
+    expect(systemMessage).toContain("Page Content:\nPage content here");
+    expect(systemMessage).not.toContain("Page Description:");
+    expect(systemMessage).not.toContain("Page URL:");
+  });
+
+  // Note: Testing maxDuration export directly would require dynamic imports
+  // which don't work well with vitest mocking. The maxDuration is set to 30
+  // in the route file and this is verified by the actual behavior during runtime.
+});