@open330/kiwimu 0.4.0 → 0.7.1

package/src/pipeline/chunker.ts

@@ -1,63 +1,16 @@
-import TurndownService from "turndown";
-import type { Section } from "../ingest/web";
-import type { Store } from "../store";
-
-const turndown = new TurndownService({ headingStyle: "atx" });
-turndown.remove(["script", "style"]);
-
 export function slugify(text: string): string {
   return text
-    .normalize("NFKD")
     .toLowerCase()
     .trim()
-    .replace(/[^\w\s-]/g, "")
+    .replace(/[^\w\s가-힣ㄱ-ㅎㅏ-ㅣ-]/g, "")
     .replace(/[-\s]+/g, "-")
     .replace(/^-|-$/g, "")
     .slice(0, 80);
 }
 
-const STOP_TITLES = new Set([
-  "introduction", "overview", "summary", "conclusion", "references",
-  "bibliography", "appendix", "abstract", "preface", "contents",
-  "table of contents", "index", "acknowledgments", "notes",
-]);
-
 export function cleanTitle(title: string): string {
   return title
     .replace(/^\s*(Chapter\s+)?\d+(\.\d+)*\s*/i, "")
     .replace(/\s+/g, " ")
     .trim();
 }
-
-export function chunkSections(sections: Section[], sourceId: number, store: Store, minWords = 30): number {
-  let count = 0;
-
-  for (const section of sections) {
-    const title = cleanTitle(section.title);
-    if (!title) continue;
-
-    const slug = slugify(title);
-    if (!slug) continue;
-
-    const htmlContent = section.htmlParts.join("\n");
-    if (!htmlContent.trim()) continue;
-
-    const content = turndown.turndown(htmlContent).trim();
-    const wordCount = content.split(/\s+/).length;
-
-    if (wordCount < minWords) continue;
-    if (STOP_TITLES.has(slug) || STOP_TITLES.has(title.toLowerCase())) {
-      if (wordCount < 100) continue;
-    }
-
-    const existing = store.getPage(slug);
-    if (existing) {
-      store.updatePageContent(existing.id, existing.content + "\n\n" + content);
-    } else {
-      store.addPage(slug, title, content, sourceId, slug);
-      count++;
-    }
-  }
-
-  return count;
-}

package/src/pipeline/llm-chunker.ts

@@ -1,14 +1,10 @@
-import { chatComplete } from "../llm-client";
+import { LLMClient } from "../llm-client";
 import type { Store } from "../store";
 import { slugify } from "./chunker";
 import type { Persona } from "../config";
 
 // ── Phase 1: Extract original document structure ──
 
-const STRUCTURE_SYSTEM = `You are a document analyzer. Extract the chapter/section structure from this textbook content, preserving the original order and hierarchy.
-
-Return valid JSON only. No markdown fences.`;
-
 const STRUCTURE_PROMPT = `Extract the document structure from this text. Preserve the original chapter/section ordering.
 
 Source: "{sourceTitle}"
@@ -89,6 +85,25 @@ interface ConceptPage {
   suggested_links?: Array<{ text: string; url: string }>;
 }
 
+async function parallelMap<T, R>(
+  items: T[],
+  concurrency: number,
+  fn: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < items.length) {
+      const i = nextIndex++;
+      results[i] = await fn(items[i], i);
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+  return results;
+}
+
 function splitByChapters(text: string): Array<{ chapterHint: string; text: string }> {
   const chapterPattern = /\n(?=(?:CHAPTER\s*\d+|Chapter\s+\d+)[A-Z\s])/g;
   const positions: number[] = [];
@@ -199,8 +214,17 @@ export async function llmChunkDocument(
   sourceId: number,
   store: Store,
   maxChunks: number = 0, // 0 = unlimited
-  persona: Persona | null = null
+  persona: Persona | null = null,
+  llmClient?: LLMClient
 ): Promise<{ sourceCount: number; conceptCount: number }> {
+  // Use provided client or fall back to deprecated global chatComplete
+  const chat = llmClient
+    ? (system: string, user: string, maxTokens?: number) => llmClient.chatComplete(system, user, maxTokens)
+    : async (system: string, user: string, maxTokens?: number) => {
+        const { chatComplete } = await import("../llm-client");
+        return chatComplete(system, user, maxTokens);
+      };
+
   let chunks = splitByChapters(rawText);
   if (maxChunks > 0 && chunks.length > maxChunks) {
     console.log(`\x1b[33m⚠ ${chunks.length}개 청크 중 ${maxChunks}개만 처리합니다\x1b[0m`);
@@ -211,61 +235,56 @@ export async function llmChunkDocument(
   }
   console.log(`\x1b[34m🧠 Phase 1: 원본 구조 추출 (${chunks.length}개 청크)...\x1b[0m`);
 
-  // ── Phase 1: Extract source pages ──
-  let orderCounter = 0;
-  const sourcePageSummaries: string[] = [];
+  // ── Phase 1: Extract source pages (parallel LLM calls) ──
+  let completedCount = 0;
+  const structureSystem = getStructureSystem(persona);
 
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    console.log(`  [${i + 1}/${chunks.length}] ${chunk.chapterHint}`);
+  const chunkResults = await parallelMap(chunks, 3, async (chunk, i) => {
+    console.log(`  Phase 1: 처리 중 [${i + 1}/${chunks.length}] ${chunk.chapterHint}...`);
 
     const prompt = STRUCTURE_PROMPT
       .replace("{sourceTitle}", sourceTitle)
       .replace("{text}", chunk.text.slice(0, 80000));
 
-    const structureSystem = getStructureSystem(persona);
     try {
-      const raw = await chatComplete(structureSystem, prompt, 16384);
+      let raw = await chat(structureSystem, prompt, 16384);
       if (!raw || raw.trim().length < 10) {
         console.log(`    \x1b[33m⚠ 빈 응답, 재시도...\x1b[0m`);
-        const retry = await chatComplete(structureSystem, prompt, 16384);
-        if (!retry || retry.trim().length < 10) {
+        raw = await chat(structureSystem, prompt, 16384);
+        if (!raw || raw.trim().length < 10) {
           console.log(`    \x1b[31m✗ 재시도도 빈 응답\x1b[0m`);
-          continue;
+          completedCount++;
+          return [] as StructurePage[];
         }
-        const sections = parseJSON<StructurePage[]>(retry).filter(s => s.title && s.content && s.content.length > 30);
-        // fall through to process sections below
-        for (const section of sections) {
-          const slug = slugify(section.title);
-          if (!slug) continue;
-          const existing = store.getPage(slug);
-          if (existing) {
-            store.updatePageContent(existing.id, existing.content + "\n\n" + section.content);
-          } else {
-            store.addPage(slug, section.title, section.content, sourceId, slug, "source", orderCounter++);
-            sourcePageSummaries.push(`- ${section.title}: ${section.content.slice(0, 150).replace(/\n/g, " ")}`);
-          }
-        }
-        console.log(`    → ${sections.length}개 섹션`);
-        continue;
       }
       const sections = parseJSON<StructurePage[]>(raw).filter(s => s.title && s.content && s.content.length > 30);
+      completedCount++;
+      console.log(`    → ${sections.length}개 섹션 (완료 ${completedCount}/${chunks.length})`);
+      return sections;
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.log(`    \x1b[31m✗ 실패: ${message}\x1b[0m`);
+      completedCount++;
+      return [] as StructurePage[];
+    }
+  });
 
-      for (const section of sections) {
-        const slug = slugify(section.title);
-        if (!slug) continue;
+  // Store results sequentially (SQLite writes must be sequential)
+  let orderCounter = 0;
+  const sourcePageSummaries: string[] = [];
 
-        const existing = store.getPage(slug);
-        if (existing) {
-          store.updatePageContent(existing.id, existing.content + "\n\n" + section.content);
-        } else {
-          store.addPage(slug, section.title, section.content, sourceId, slug, "source", orderCounter++);
-          sourcePageSummaries.push(`- ${section.title}: ${section.content.slice(0, 150).replace(/\n/g, " ")}`);
-        }
+  for (const sections of chunkResults) {
+    for (const section of sections) {
+      const slug = slugify(section.title);
+      if (!slug) continue;
+
+      const existing = store.getPage(slug);
+      if (existing) {
+        store.updatePageContent(existing.id, existing.content + "\n\n" + section.content);
+      } else {
+        store.addPage(slug, section.title, section.content, sourceId, slug, "source", orderCounter++);
+        sourcePageSummaries.push(`- ${section.title}: ${section.content.slice(0, 150).replace(/\n/g, " ")}`);
       }
-      console.log(`    → ${sections.length}개 섹션`);
-    } catch (e: any) {
-      console.log(`    \x1b[31m✗ 실패: ${e.message}\x1b[0m`);
     }
   }
 
@@ -292,7 +311,7 @@ export async function llmChunkDocument(
     const conceptSystem = getConceptSystem(persona);
 
     try {
-      const raw = await chatComplete(conceptSystem, prompt, 16384);
+      const raw = await chat(conceptSystem, prompt, 16384);
       const concepts = parseJSON<ConceptPage[]>(raw).filter(c => c.title && c.content && c.content.length > 50);
 
       for (const concept of concepts) {
@@ -315,13 +334,67 @@ export async function llmChunkDocument(
         conceptCount++;
       }
       console.log(`    → ${concepts.length}개 개념`);
-    } catch (e: any) {
-      console.log(`    \x1b[31m✗ 실패: ${e.message}\x1b[0m`);
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.log(`    \x1b[31m✗ 실패: ${message}\x1b[0m`);
     }
   }
 
   console.log(`\x1b[32m  📝 ${conceptCount}개 개념 페이지 생성 완료\x1b[0m`);
 
+  // ── Phase 2.5: Generate quizzes from concept pages ──
+  let quizCount = 0;
+  try {
+    const conceptPagesForQuiz = store.listConceptPages();
+    if (conceptPagesForQuiz.length > 0) {
+      console.log(`\x1b[34m🧠 Phase 2.5: 퀴즈 생성 (${conceptPagesForQuiz.length}개 개념 페이지)...\x1b[0m`);
+
+      const quizSystem = `You are a quiz generator for a study wiki. Generate quiz questions based on wiki content.
+Return valid JSON only. No markdown fences.`;
+
+      await parallelMap(conceptPagesForQuiz, 3, async (page, i) => {
+        try {
+          const quizPrompt = `Based on this wiki content, generate 2-3 quiz questions in JSON format.
+Types: "fill_blank" (빈칸 채우기), "ox" (OX 퀴즈 - true/false), "short_answer" (단답형)
+
+Content title: ${page.title}
+Content:
+${page.content.slice(0, 3000)}
+
+Respond with a JSON array only:
+[{"question": "___은 양자역학에서 위치와 운동량을 동시에 측정할 수 없다는 원리이다.", "answer": "불확정성 원리", "type": "fill_blank"}]
+
+Rules:
+- For fill_blank: use ___ to mark the blank in the question
+- For ox: question should be a statement, answer should be "O" or "X"
+- For short_answer: question should be answerable in 1-3 words
+- Questions should test understanding, not just recall
+- Write questions in Korean when the content is in Korean`;
+
+          const raw = await chat(quizSystem, quizPrompt, 2048);
+          const quizzes = parseJSON<Array<{ question: string; answer: string; type: string }>>(raw);
+
+          for (const q of quizzes) {
+            if (q.question && q.answer && q.type) {
+              store.addQuiz(page.id, q.question, q.answer, q.type);
+              quizCount++;
+            }
+          }
+        } catch (e: unknown) {
+          // Quiz generation is non-critical; silently skip failures
+          const message = e instanceof Error ? e.message : String(e);
+          console.log(`    \x1b[33m⚠ 퀴즈 생성 실패 (${page.title}): ${message}\x1b[0m`);
+        }
+      });
+
+      console.log(`\x1b[32m  🧩 ${quizCount}개 퀴즈 생성 완료\x1b[0m`);
+    }
+  } catch (e: unknown) {
+    // Phase 2.5 is optional — don't block the pipeline
+    const message = e instanceof Error ? e.message : String(e);
+    console.log(`\x1b[33m  ⚠ 퀴즈 생성 단계 건너뜀: ${message}\x1b[0m`);
+  }
+
   // ── Phase 3: Resolve wiki links + inject concept links into source pages ──
   console.log(`\x1b[34m🔗 위키 링크 해석 중...\x1b[0m`);
   const allPages = store.listPages();
@@ -347,31 +420,36 @@ export async function llmChunkDocument(
   const srcPages = allPages.filter(p => p.page_type === "source");
 
   // Build search terms: full title + key words from title (2+ words long)
-  const searchTerms: Array<{ term: string; concept: typeof conceptPages[0] }> = [];
+  const searchTerms: Array<{ term: string; concept: typeof conceptPages[0]; regex: RegExp | null }> = [];
   for (const concept of conceptPages) {
-    searchTerms.push({ term: concept.title, concept });
+    searchTerms.push({ term: concept.title, concept, regex: null });
     // Also try individual significant words from multi-word titles
     const words = concept.title.split(/\s+/).filter(w => w.length >= 4 && !/^(and|the|for|with|from|into)$/i.test(w));
     if (words.length >= 2) {
       // Try pairs of consecutive words
       for (let i = 0; i < words.length - 1; i++) {
-        searchTerms.push({ term: `${words[i]} ${words[i + 1]}`, concept });
+        searchTerms.push({ term: `${words[i]} ${words[i + 1]}`, concept, regex: null });
       }
     }
   }
   // Sort by term length descending for longest match first
   searchTerms.sort((a, b) => b.term.length - a.term.length);
 
+  // Pre-compile RegExp objects outside the page loop
+  for (const entry of searchTerms) {
+    if (entry.term.length < 3) continue;
+    const escaped = entry.term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    entry.regex = new RegExp(`(?<!\\[)(?<![\\w/])(${escaped})(?![\\w])(?!\\])(?![^[]*\\])`, "i");
+  }
+
   for (const srcPage of srcPages) {
     let content = srcPage.content;
     let modified = false;
     const linkedConcepts = new Set<number>();
 
-    for (const { term, concept } of searchTerms) {
+    for (const { term, concept, regex } of searchTerms) {
       if (linkedConcepts.has(concept.id)) continue; // One link per concept per page
-      if (term.length < 3) continue;
-      const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const regex = new RegExp(`(?<!\\[)(?<![\\w/])(${escaped})(?![\\w])(?!\\])(?![^[]*\\])`, "i");
+      if (term.length < 3 || !regex) continue;
       const match = regex.exec(content);
       if (match) {
         const replacement = `[${match[1]}](/wiki/${concept.slug})`;

package/src/server.ts

@@ -0,0 +1,327 @@
+import { join } from "path";
+import path from "path";
+import crypto from "crypto";
+import { DB_FILE, loadConfig, saveConfig, getActivePersona } from "./config";
+import { Store } from "./store";
+import type { KiwiConfig } from "./config";
+
+export function startServer(root: string, port: number, host: string): void {
+  const config = loadConfig(root);
+  const siteDir = join(root, config.build.output_dir);
+
+  let isProcessing = false;
+  let processingStatus = "";
+
+  const hostname = host;
+  const authToken = crypto.randomUUID();
+  console.log(`\x1b[32m🥝 Kiwi Mu 서버 시작!\x1b[0m`);
+  console.log(`  http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`);
+  console.log(`  관리 페이지: http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}/admin?token=${authToken}`);
+  console.log(`  인증 토큰: ${authToken}`);
+  if (hostname === "0.0.0.0") console.log("  네트워크에 공개됨 (0.0.0.0)");
+  console.log("  웹에서 문서 추가 가능합니다.\n");
+
+  Bun.serve({
+    port,
+    hostname,
+    async fetch(req) {
+      const url = new URL(req.url);
+
+      // ── Auth middleware for /api/* and /admin ──
+      if (url.pathname.startsWith("/api/") || url.pathname === "/admin") {
+        const authHeader = req.headers.get("Authorization");
+        const queryToken = url.searchParams.get("token");
+        const bearerToken = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+        if (bearerToken !== authToken && queryToken !== authToken) {
+          return Response.json({ error: "Unauthorized" }, { status: 401 });
+        }
+      }
+
+      // ── API endpoints ──
+
+      // File upload endpoint
+      if (url.pathname === "/api/upload" && req.method === "POST") {
+        if (isProcessing) {
+          return Response.json({ error: "이미 처리 중입니다", status: processingStatus }, { status: 409 });
+        }
+
+        const formData = await req.formData();
+        const file = formData.get("file") as File | null;
+        if (!file) {
+          return Response.json({ error: "파일이 필요합니다" }, { status: 400 });
+        }
+
+        const MAX_UPLOAD_SIZE = 50 * 1024 * 1024; // 50MB
+        if (file.size > MAX_UPLOAD_SIZE) {
+          return Response.json({ error: "파일 크기가 50MB를 초과합니다" }, { status: 413 });
+        }
+
+        const ext = file.name.split(".").pop()?.toLowerCase() || "";
+        const supported = ["pdf", "docx", "doc", "pptx", "ppt", "key", "rtf"];
+        if (!supported.includes(ext)) {
+          return Response.json({ error: `지원하지 않는 형식: .${ext}. 지원: ${supported.join(", ")}` }, { status: 400 });
+        }
+
+        // Save uploaded file
+        const uploadDir = join(root, "uploads");
+        const { mkdirSync } = await import("fs");
+        mkdirSync(uploadDir, { recursive: true });
+        const filePath = join(uploadDir, path.basename(file.name));
+        await Bun.write(filePath, await file.arrayBuffer());
+
+        isProcessing = true;
+        processingStatus = "파일 처리 시작...";
+
+        (async () => {
+          const store = new Store(join(root, DB_FILE));
+          try {
+            const { ingestFile } = await import("./services/ingest");
+            const currentConfig = loadConfig(root);
+            const currentPersona = getActivePersona(currentConfig);
+
+            await ingestFile(root, store, filePath, file.name, currentConfig.llm, currentPersona, (status) => {
+              processingStatus = status;
+            });
+
+            processingStatus = "빌드 중...";
+            const { buildSite } = await import("./build/renderer");
+            await buildSite(store, loadConfig(root), root);
+
+            processingStatus = "완료!";
+          } catch (e: unknown) {
+            const message = e instanceof Error ? e.message : String(e);
+            processingStatus = `오류: ${message}`;
+          } finally {
+            store.close();
+            setTimeout(() => { isProcessing = false; }, 2000);
+          }
+        })();
+
+        return Response.json({ ok: true, message: "파일 처리 시작" });
+      }
+
+      // URL add endpoint
+      if (url.pathname === "/api/add" && req.method === "POST") {
+        if (isProcessing) {
+          return Response.json({ error: "이미 처리 중입니다", status: processingStatus }, { status: 409 });
+        }
+
+        const body = await req.json() as { source: string };
+        if (!body.source) {
+          return Response.json({ error: "source가 필요합니다" }, { status: 400 });
+        }
+
+        try {
+          const { validateUrl } = await import("./ingest/web");
+          validateUrl(body.source);
+        } catch (e: unknown) {
+          const message = e instanceof Error ? e.message : String(e);
+          return Response.json({ error: message }, { status: 400 });
+        }
+
+        isProcessing = true;
+        processingStatus = "시작 중...";
+
+        (async () => {
+          const store = new Store(join(root, DB_FILE));
+          try {
+            const { ingestUrl } = await import("./services/ingest");
+            const currentConfig = loadConfig(root);
+            const currentPersona = getActivePersona(currentConfig);
+
+            await ingestUrl(root, store, body.source, currentConfig.llm, currentPersona, (status) => {
+              processingStatus = status;
+            });
+
+            processingStatus = "빌드 중...";
+            const { buildSite } = await import("./build/renderer");
+            await buildSite(store, loadConfig(root), root);
+
+            processingStatus = "완료!";
+          } catch (e: unknown) {
+            const message = e instanceof Error ? e.message : String(e);
+            processingStatus = `오류: ${message}`;
+          } finally {
+            store.close();
+            setTimeout(() => { isProcessing = false; }, 2000);
+          }
+        })();
+
+        return Response.json({ ok: true, message: "처리 시작" });
+      }
+
+      // Admin API - update LLM settings
+      if (url.pathname === "/api/settings" && req.method === "POST") {
+        const body = await req.json() as Record<string, string | undefined>;
+        const currentConfig = loadConfig(root);
+        if (body.wiki_name) currentConfig.project.name = body.wiki_name;
+        if (body.provider) currentConfig.llm.provider = body.provider;
+        if (body.model) currentConfig.llm.model = body.model;
+        if (body.api_key !== undefined) currentConfig.llm.api_key = body.api_key ?? "";
+        if (body.endpoint !== undefined) currentConfig.llm.endpoint = body.endpoint ?? "";
+        saveConfig(root, currentConfig);
+        // Reload config for serve
+        Object.assign(config, currentConfig);
+
+        // Auto-rebuild site with new settings
+        (async () => {
+          const store = new Store(join(root, DB_FILE));
+          try {
+            const { buildSite } = await import("./build/renderer");
+            await buildSite(store, currentConfig, root);
+            console.log("\x1b[32m✅ 설정 변경 후 사이트 리빌드 완료\x1b[0m");
+          } catch (e: unknown) {
+            const message = e instanceof Error ? e.message : String(e);
+            console.log(`\x1b[31m리빌드 실패: ${message}\x1b[0m`);
+          } finally {
+            store.close();
+          }
+        })();
+
+        return Response.json({ ok: true });
+      }
+
+      if (url.pathname === "/api/settings" && req.method === "GET") {
+        const currentConfig = loadConfig(root);
+        // Mask API key
+        const masked = { ...currentConfig.llm, api_key: currentConfig.llm.api_key ? "••••" + currentConfig.llm.api_key.slice(-4) : "" };
+        return Response.json(masked);
+      }
+
+      // Persona API
+      if (url.pathname === "/api/personas" && req.method === "GET") {
+        const currentConfig = loadConfig(root);
+        return Response.json({
+          personas: currentConfig.personas || [],
+          active: currentConfig.active_persona || "",
+        });
+      }
+
+      if (url.pathname === "/api/personas" && req.method === "POST") {
+        const body = await req.json() as Record<string, unknown>;
+        const currentConfig = loadConfig(root);
+        if (!currentConfig.personas) currentConfig.personas = [];
+
+        if (body.action === "add") {
+          const persona = body.persona as { name: string; description?: string; system_prompt?: string; content_style?: string };
+          const { name, description, system_prompt, content_style } = persona;
+          if (!name) return Response.json({ error: "이름이 필요합니다" }, { status: 400 });
+          if (currentConfig.personas.find(p => p.name === name)) {
+            return Response.json({ error: "이미 존재하는 페르소나입니다" }, { status: 409 });
+          }
+          currentConfig.personas.push({ name, description: description || "", system_prompt: system_prompt || "", content_style: content_style || "" });
+        } else if (body.action === "update") {
+          const originalName = body.original_name as string;
+          const persona = body.persona as { name: string; description: string; system_prompt: string; content_style: string };
+          const idx = currentConfig.personas.findIndex(p => p.name === originalName);
+          if (idx === -1) return Response.json({ error: "페르소나를 찾을 수 없습니다" }, { status: 404 });
+          currentConfig.personas[idx] = persona;
+          if (currentConfig.active_persona === originalName && persona.name !== originalName) {
+            currentConfig.active_persona = persona.name;
+          }
+        } else if (body.action === "delete") {
+          const name = body.name as string;
+          currentConfig.personas = currentConfig.personas.filter(p => p.name !== name);
+          if (currentConfig.active_persona === name) {
+            currentConfig.active_persona = currentConfig.personas[0]?.name || "";
+          }
+        } else if (body.action === "activate") {
+          const name = body.name as string;
+          if (!currentConfig.personas.find(p => p.name === name)) {
+            return Response.json({ error: "페르소나를 찾을 수 없습니다" }, { status: 404 });
+          }
+          currentConfig.active_persona = name;
+        }
+
+        saveConfig(root, currentConfig);
+        Object.assign(config, currentConfig);
+        return Response.json({ ok: true, personas: currentConfig.personas, active: currentConfig.active_persona });
+      }
+
+      // Build API
+      if (url.pathname === "/api/build" && req.method === "POST") {
+        if (isProcessing) {
+          return Response.json({ error: "이미 처리 중입니다" }, { status: 409 });
+        }
+        isProcessing = true;
+        processingStatus = "빌드 중...";
+        (async () => {
+          const store = new Store(join(root, DB_FILE));
+          try {
+            const { buildSite } = await import("./build/renderer");
+            await buildSite(store, loadConfig(root), root);
+            processingStatus = "빌드 완료!";
+            console.log("\x1b[32m✅ 수동 빌드 완료\x1b[0m");
+          } catch (e: unknown) {
+            const message = e instanceof Error ? e.message : String(e);
+            processingStatus = `빌드 오류: ${message}`;
+          } finally {
+            store.close();
+            setTimeout(() => { isProcessing = false; }, 2000);
+          }
+        })();
+        return Response.json({ ok: true, message: "빌드 시작" });
+      }
+
+      // Admin page
+      if (url.pathname === "/admin") {
+        const store = new Store(join(root, DB_FILE));
+        const sources = store.listSourcesMeta();
+        const usage = store.getUsageSummary();
+        const configData = loadConfig(root);
+        store.close();
+
+        const { renderAdmin } = await import("./build/templates");
+        return new Response(renderAdmin({
+          wikiName: configData.project.name,
+          sources,
+          usage,
+          llmConfig: configData.llm,
+          personas: configData.personas || [],
+          activePersona: configData.active_persona || "",
+          authToken,
+        }), { headers: { "Content-Type": "text/html" } });
+      }
+
+      if (url.pathname === "/api/status") {
+        const store = new Store(join(root, DB_FILE));
+        const sources = store.listSourcesMeta();
+        const sourcePages = store.listSourcePages();
+        const conceptPages = store.listConceptPages();
+        const links = store.getAllLinks();
+        const usage = store.getUsageSummary();
+        store.close();
+
+        return Response.json({
+          processing: isProcessing,
+          processingStatus,
+          sources: sources.length,
+          sourcePages: sourcePages.length,
+          conceptPages: conceptPages.length,
+          links: links.length,
+          usage,
+        });
+      }
+
+      // ── Static file serving ──
+      let pathname = url.pathname;
+      if (pathname === "/") pathname = "/index.html";
+
+      const resolved = path.resolve(join(siteDir, pathname));
+      if (!resolved.startsWith(path.resolve(siteDir))) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      const staticFile = Bun.file(resolved);
+
+      if (await staticFile.exists()) {
+        const isHtml = pathname.endsWith(".html");
+        const cspValue = "default-src 'self'; script-src 'self' 'unsafe-inline' cdn.jsdelivr.net d3js.org; style-src 'self' 'unsafe-inline' cdn.jsdelivr.net fonts.googleapis.com; font-src fonts.gstatic.com; img-src * data:; connect-src 'self'";
+        if (isHtml) {
+          return new Response(staticFile, { headers: { "Content-Type": "text/html", "Content-Security-Policy": cspValue } });
+        }
+        return new Response(staticFile);
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+  });
+}