@open330/kiwimu 0.4.1 → 0.8.0

package/src/store.ts

@@ -20,12 +20,32 @@ export interface Page {
   display_order: number;
 }
 
+export interface SourceMeta {
+  id: number;
+  uri: string;
+  type: string;
+  title: string;
+  fetched_at: string;
+}
+
 export interface Link {
   from_page_id: number;
   to_page_id: number;
   anchor_text: string;
 }
 
+export interface Quiz {
+  id: number;
+  page_id: number;
+  question: string;
+  answer: string;
+  explanation: string;
+  quiz_type: string; // 'fill_blank' | 'ox' | 'short_answer'
+  created_at: string;
+  page_title?: string;
+  page_slug?: string;
+}
+
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS sources (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -63,6 +83,29 @@ CREATE TABLE IF NOT EXISTS links (
   anchor_text TEXT,
   PRIMARY KEY (from_page_id, to_page_id, anchor_text)
 );
+CREATE TABLE IF NOT EXISTS quizzes (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  page_id INTEGER NOT NULL,
+  question TEXT NOT NULL,
+  answer TEXT NOT NULL,
+  explanation TEXT DEFAULT '',
+  quiz_type TEXT NOT NULL DEFAULT 'fill_blank',
+  created_at TEXT DEFAULT (datetime('now')),
+  FOREIGN KEY (page_id) REFERENCES pages(id)
+);
+CREATE TABLE IF NOT EXISTS quiz_attempts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  quiz_id INTEGER NOT NULL,
+  is_correct INTEGER NOT NULL DEFAULT 0,
+  attempted_at TEXT DEFAULT (datetime('now')),
+  FOREIGN KEY (quiz_id) REFERENCES quizzes(id)
+);
+CREATE INDEX IF NOT EXISTS idx_pages_source_id ON pages(source_id);
+CREATE INDEX IF NOT EXISTS idx_attempts_quiz_id ON quiz_attempts(quiz_id);
+CREATE INDEX IF NOT EXISTS idx_pages_page_type ON pages(page_type);
+CREATE INDEX IF NOT EXISTS idx_links_to_page ON links(to_page_id);
+CREATE INDEX IF NOT EXISTS idx_links_from_page ON links(from_page_id);
+CREATE INDEX IF NOT EXISTS idx_quizzes_page_id ON quizzes(page_id);
 `;
 
 export class Store {
@@ -76,6 +119,12 @@ export class Store {
 
   initSchema(): void {
     this.db.exec(SCHEMA);
+    // Migrate: add explanation column if missing (for existing databases)
+    try {
+      this.db.exec("ALTER TABLE quizzes ADD COLUMN explanation TEXT DEFAULT ''");
+    } catch {
+      // Column already exists — ignore
+    }
   }
 
   close(): void {
@@ -107,6 +156,10 @@ export class Store {
     return this.db.prepare("SELECT * FROM sources ORDER BY fetched_at DESC").all() as Source[];
   }
 
+  listSourcesMeta(): SourceMeta[] {
+    return this.db.prepare("SELECT id, uri, type, title, fetched_at FROM sources ORDER BY id DESC").all() as SourceMeta[];
+  }
+
   // --- Pages ---
 
   addPage(
@@ -147,7 +200,15 @@ export class Store {
   }
 
   deletePagesBySource(sourceId: number): void {
-    // Delete links involving these pages first
+    // Delete quiz attempts for quizzes on these pages first
+    this.db.prepare(
+      "DELETE FROM quiz_attempts WHERE quiz_id IN (SELECT id FROM quizzes WHERE page_id IN (SELECT id FROM pages WHERE source_id = ?))"
+    ).run(sourceId);
+    // Delete quizzes for these pages
+    this.db.prepare(
+      "DELETE FROM quizzes WHERE page_id IN (SELECT id FROM pages WHERE source_id = ?)"
+    ).run(sourceId);
+    // Delete links involving these pages
     this.db.prepare(
       "DELETE FROM links WHERE from_page_id IN (SELECT id FROM pages WHERE source_id = ?) OR to_page_id IN (SELECT id FROM pages WHERE source_id = ?)"
     ).run(sourceId, sourceId);
@@ -155,6 +216,8 @@ export class Store {
   }
 
   deleteAllPages(): void {
+    this.db.exec("DELETE FROM quiz_attempts");
+    this.db.exec("DELETE FROM quizzes");
     this.db.exec("DELETE FROM links");
     this.db.exec("DELETE FROM pages");
   }
@@ -192,6 +255,147 @@ export class Store {
     return this.db.prepare("SELECT * FROM links").all() as Link[];
   }
 
+  getAllBacklinksGrouped(): Map<number, Array<{id: number; slug: string; title: string; page_type: string}>> {
+    const rows = this.db.prepare(`
+      SELECT l.to_page_id, p.id, p.slug, p.title, p.page_type
+      FROM links l
+      JOIN pages p ON p.id = l.from_page_id
+      ORDER BY l.to_page_id
+    `).all() as Array<{to_page_id: number; id: number; slug: string; title: string; page_type: string}>;
+
+    const map = new Map<number, Array<{id: number; slug: string; title: string; page_type: string}>>();
+    for (const row of rows) {
+      if (!map.has(row.to_page_id)) map.set(row.to_page_id, []);
+      map.get(row.to_page_id)!.push({ id: row.id, slug: row.slug, title: row.title, page_type: row.page_type });
+    }
+    return map;
+  }
+
+  // --- Quizzes ---
+
+  addQuiz(pageId: number, question: string, answer: string, quizType: string, explanation: string = ""): void {
+    this.db
+      .prepare("INSERT INTO quizzes (page_id, question, answer, explanation, quiz_type) VALUES (?, ?, ?, ?, ?)")
+      .run(pageId, question, answer, explanation, quizType);
+  }
+
+  getQuizzesByPage(pageId: number): Quiz[] {
+    return this.db
+      .prepare(
+        `SELECT q.*, p.title as page_title, p.slug as page_slug
+         FROM quizzes q JOIN pages p ON p.id = q.page_id
+         WHERE q.page_id = ? ORDER BY q.id`
+      )
+      .all(pageId) as Quiz[];
+  }
+
+  getAllQuizzes(): Quiz[] {
+    return this.db
+      .prepare(
+        `SELECT q.*, p.title as page_title, p.slug as page_slug
+         FROM quizzes q JOIN pages p ON p.id = q.page_id
+         ORDER BY q.id`
+      )
+      .all() as Quiz[];
+  }
+
+  getRandomQuizzes(count: number): Quiz[] {
+    return this.db
+      .prepare(
+        `SELECT q.*, p.title as page_title, p.slug as page_slug
+         FROM quizzes q JOIN pages p ON p.id = q.page_id
+         ORDER BY RANDOM() LIMIT ?`
+      )
+      .all(count) as Quiz[];
+  }
+
+  deleteQuizzesByPage(pageId: number): void {
+    this.db.prepare("DELETE FROM quizzes WHERE page_id = ?").run(pageId);
+  }
+
+  getSmartQuizzes(count: number): Quiz[] {
+    return this.db.prepare(`
+      SELECT q.*, p.title as page_title, p.slug as page_slug,
+        COALESCE(a.last_attempt, '1970-01-01') as last_attempt,
+        COALESCE(a.correct_count, 0) as correct_count,
+        COALESCE(a.wrong_count, 0) as wrong_count
+      FROM quizzes q
+      JOIN pages p ON p.id = q.page_id
+      LEFT JOIN (
+        SELECT quiz_id,
+          MAX(attempted_at) as last_attempt,
+          SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END) as correct_count,
+          SUM(CASE WHEN is_correct = 0 THEN 1 ELSE 0 END) as wrong_count
+        FROM quiz_attempts
+        GROUP BY quiz_id
+      ) a ON a.quiz_id = q.id
+      ORDER BY
+        CASE WHEN a.last_attempt IS NULL THEN 0 ELSE 1 END,
+        CASE WHEN a.wrong_count > 0 THEN 0 ELSE 1 END,
+        a.last_attempt ASC
+      LIMIT ?
+    `).all(count) as Quiz[];
+  }
+
+  // --- Quiz Attempts ---
+
+  addQuizAttempt(quizId: number, isCorrect: boolean): void {
+    this.db
+      .prepare("INSERT INTO quiz_attempts (quiz_id, is_correct) VALUES (?, ?)")
+      .run(quizId, isCorrect ? 1 : 0);
+  }
+
+  getQuizStats(): { total: number; correct: number; incorrect: number; unattempted: number } {
+    const totalQuizzes = (this.db.prepare("SELECT COUNT(*) as cnt FROM quizzes").get() as { cnt: number }).cnt;
+    const attemptRow = this.db.prepare(`
+      SELECT COUNT(*) as total,
+        SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END) as correct,
+        SUM(CASE WHEN is_correct = 0 THEN 1 ELSE 0 END) as incorrect
+      FROM quiz_attempts
+    `).get() as { total: number; correct: number; incorrect: number };
+    const attemptedQuizzes = (this.db.prepare("SELECT COUNT(DISTINCT quiz_id) as cnt FROM quiz_attempts").get() as { cnt: number }).cnt;
+    return {
+      total: attemptRow.total,
+      correct: attemptRow.correct,
+      incorrect: attemptRow.incorrect,
+      unattempted: totalQuizzes - attemptedQuizzes,
+    };
+  }
+
+  getWeakQuizzes(limit: number): Quiz[] {
+    return this.db.prepare(`
+      SELECT q.*, p.title as page_title, p.slug as page_slug
+      FROM quizzes q
+      JOIN pages p ON p.id = q.page_id
+      LEFT JOIN (
+        SELECT quiz_id,
+          SUM(CASE WHEN is_correct = 0 THEN 1 ELSE 0 END) as wrong_count,
+          COUNT(*) as attempt_count
+        FROM quiz_attempts
+        GROUP BY quiz_id
+      ) a ON a.quiz_id = q.id
+      ORDER BY
+        CASE WHEN a.attempt_count IS NULL THEN 1 ELSE 0 END DESC,
+        COALESCE(a.wrong_count, 0) DESC
+      LIMIT ?
+    `).all(limit) as Quiz[];
+  }
+
+  getQuizHistory(limit: number): Array<{ quiz_id: number; question: string; is_correct: boolean; attempted_at: string }> {
+    return this.db.prepare(`
+      SELECT qa.quiz_id, q.question, qa.is_correct, qa.attempted_at
+      FROM quiz_attempts qa
+      JOIN quizzes q ON q.id = qa.quiz_id
+      ORDER BY qa.attempted_at DESC
+      LIMIT ?
+    `).all(limit).map((row: any) => ({
+      quiz_id: row.quiz_id,
+      question: row.question,
+      is_correct: row.is_correct === 1,
+      attempted_at: row.attempted_at,
+    }));
+  }
+
   // --- Usage ---
 
   addUsageLog(sourceId: number, calls: number, prompt: number, completion: number, total: number, cost: number): void {
@@ -203,7 +407,7 @@ export class Store {
   getUsageSummary(): { totalCalls: number; promptTokens: number; completionTokens: number; totalTokens: number; totalCost: number } {
     const row = this.db.prepare(
       "SELECT COALESCE(SUM(llm_calls),0) as totalCalls, COALESCE(SUM(prompt_tokens),0) as promptTokens, COALESCE(SUM(completion_tokens),0) as completionTokens, COALESCE(SUM(total_tokens),0) as totalTokens, COALESCE(SUM(estimated_cost_usd),0) as totalCost FROM usage_logs"
-    ).get() as any;
+    ).get() as { totalCalls: number; promptTokens: number; completionTokens: number; totalTokens: number; totalCost: number };
     return row;
   }
 }

package/src/pipeline/llm-linker.ts

@@ -1,84 +0,0 @@
-import { chatComplete } from "../llm-client";
-import type { Store } from "../store";
-import { slugify } from "./chunker";
-
-const LINK_SYSTEM = `You are a wiki editor. Given wiki pages, find cross-link opportunities that were missed.
-Return valid JSON only. No markdown fences.`;
-
-const LINK_PROMPT = `These wiki pages exist but may be missing cross-links. Find where one page's content mentions a concept that has its own page.
-
-Pages (slug | title | first 300 chars of content):
-{pages}
-
-Return JSON:
-{
-  "links": [
-    {
-      "from_slug": "source-page-slug",
-      "to_slug": "target-page-slug",
-      "anchor_text": "exact phrase in source page to link"
-    }
-  ]
-}
-
-Rules:
-- anchor_text MUST be an exact phrase found in the source page content
-- Only link genuinely related concepts
-- 3-8 links per page where meaningful
-- Do NOT link a page to itself`;
-
-export async function llmLinkPages(store: Store): Promise<number> {
-  const pages = store.listPages();
-  if (pages.length < 2) return 0;
-
-  const batchSize = 30;
-  let totalLinks = 0;
-
-  for (let i = 0; i < pages.length; i += batchSize) {
-    const batch = pages.slice(i, i + batchSize);
-    const pagesText = batch
-      .map(p => `${p.slug} | ${p.title} | ${p.content.slice(0, 300).replace(/\n/g, " ")}`)
-      .join("\n");
-
-    try {
-      const raw = await chatComplete(LINK_SYSTEM, LINK_PROMPT.replace("{pages}", pagesText), 8192);
-      let cleaned = raw.replace(/^```json?\n?/m, "").replace(/\n?```$/m, "").trim();
-
-      let result: { links: Array<{ from_slug: string; to_slug: string; anchor_text: string }> };
-      try {
-        result = JSON.parse(cleaned);
-      } catch {
-        // Try to repair truncated JSON
-        cleaned = cleaned.replace(/,?\s*$/, "]}");
-        try {
-          result = JSON.parse(cleaned);
-        } catch {
-          console.log(`    \x1b[33m⚠ 링크 JSON 파싱 실패\x1b[0m`);
-          continue;
-        }
-      }
-
-      const slugToPage = new Map(pages.map(p => [p.slug, p]));
-
-      for (const link of result.links) {
-        const fromPage = slugToPage.get(link.from_slug);
-        const toPage = slugToPage.get(link.to_slug);
-        if (!fromPage || !toPage || fromPage.id === toPage.id) continue;
-
-        const anchor = link.anchor_text;
-        if (anchor && fromPage.content.includes(anchor) && !fromPage.content.includes(`[${anchor}]`)) {
-          const linkedText = `[${anchor}](/wiki/${link.to_slug})`;
-          const newContent = fromPage.content.replace(anchor, linkedText);
-          store.updatePageContent(fromPage.id, newContent);
-          fromPage.content = newContent;
-          store.addLink(fromPage.id, toPage.id, anchor);
-          totalLinks++;
-        }
-      }
-    } catch (e: any) {
-      console.log(`    \x1b[31m링크 생성 실패: ${e.message}\x1b[0m`);
-    }
-  }
-
-  return totalLinks;
-}