Phase 5 구현: SQLite DB + History/Dictionary 서비스 + UI

- DB: better-sqlite3 + drizzle-orm (history/dictionary/stats, WAL 모드)
- HistoryService: CRUD + 검색 + 통계 + 30일 보존 정책, 세션 완료 시 자동 저장
- DictionaryService: CRUD + 검색 + 사용 횟수 추적 + STT 프롬프트 힌트
- HistoryPage: 목록 + 검색 + 삭제 + 복사 + 페이지네이션
- DictionaryPage: 목록 + 검색 + 추가 다이얼로그 + 삭제
- DashboardPage: 실데이터 통계 (총/오늘 세션, 시간, 단어수, 연속일수)
- IPC: history/dictionary/stats 핸들러 + preload API
- Bootstrap: DB 초기화 (critical) + 이력 자동 저장 연동

src/main/services/DictionaryService.ts

@@ -0,0 +1,170 @@
+// src/main/services/DictionaryService.ts
+// 사용자 커스텀 단어 사전. 설계서 01/03 IDictionaryService 구현.
+
+import { eq, like, desc, count, sql } from 'drizzle-orm'
+import { nanoid } from 'nanoid'
+import { getDatabase } from '../db'
+import { dictionary } from '../db/schema'
+import type { Dictionary, NewDictionary } from '../db/schema'
+import { getLogger } from './LoggerService'
+import type {
+  DictionaryEntry,
+  DictionaryQueryParams,
+  DictionaryPage,
+  DictionaryAddParams,
+  DictionaryUpdateParams,
+  DictionarySearchParams
+} from '@shared/types'
+
+const logger = getLogger('DictionaryService')
+
+class DictionaryService {
+  add(params: DictionaryAddParams): DictionaryEntry {
+    const db = getDatabase()
+    const now = Date.now()
+    const id = nanoid()
+
+    const entry: NewDictionary = {
+      id,
+      word: params.word,
+      pronunciation: params.pronunciation ?? null,
+      category: params.category ?? 'user',
+      usageCount: 0,
+      lastUsedAt: null,
+      createdAt: now,
+      updatedAt: now
+    }
+
+    db.insert(dictionary).values(entry).run()
+    logger.info(`Dictionary entry added: "${params.word}"`)
+    return this._toEntry(entry as Dictionary)
+  }
+
+  update(params: DictionaryUpdateParams): DictionaryEntry | null {
+    const db = getDatabase()
+    const existing = db.select().from(dictionary).where(eq(dictionary.id, params.id)).get()
+    if (!existing) return null
+
+    const updates: Partial<NewDictionary> = { updatedAt: Date.now() }
+    if (params.word !== undefined) updates.word = params.word
+    if (params.pronunciation !== undefined) updates.pronunciation = params.pronunciation
+    if (params.category !== undefined) updates.category = params.category
+
+    db.update(dictionary).set(updates).where(eq(dictionary.id, params.id)).run()
+
+    const updated = db.select().from(dictionary).where(eq(dictionary.id, params.id)).get()
+    return updated ? this._toEntry(updated) : null
+  }
+
+  delete(id: string): boolean {
+    const db = getDatabase()
+    const result = db.delete(dictionary).where(eq(dictionary.id, id)).run()
+    return result.changes > 0
+  }
+
+  list(params: DictionaryQueryParams): DictionaryPage {
+    const db = getDatabase()
+    const { page, pageSize } = params
+
+    const totalResult = db.select({ count: count() }).from(dictionary).get()
+    const total = totalResult?.count ?? 0
+
+    const entries = db
+      .select()
+      .from(dictionary)
+      .orderBy(desc(dictionary.createdAt))
+      .limit(pageSize)
+      .offset(page * pageSize)
+      .all()
+
+    return {
+      entries: entries.map((e) => this._toEntry(e)),
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize)
+    }
+  }
+
+  search(params: DictionarySearchParams): DictionaryPage {
+    const db = getDatabase()
+    const { query, page, pageSize } = params
+    const pattern = `%${query}%`
+
+    const totalResult = db
+      .select({ count: count() })
+      .from(dictionary)
+      .where(like(dictionary.word, pattern))
+      .get()
+    const total = totalResult?.count ?? 0
+
+    const entries = db
+      .select()
+      .from(dictionary)
+      .where(like(dictionary.word, pattern))
+      .orderBy(desc(dictionary.usageCount))
+      .limit(pageSize)
+      .offset(page * pageSize)
+      .all()
+
+    return {
+      entries: entries.map((e) => this._toEntry(e)),
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize)
+    }
+  }
+
+  incrementUsage(id: string): void {
+    const db = getDatabase()
+    db.update(dictionary)
+      .set({
+        usageCount: sql`usage_count + 1`,
+        lastUsedAt: Date.now()
+      })
+      .where(eq(dictionary.id, id))
+      .run()
+  }
+
+  /**
+   * 사전 단어 목록을 STT initialPrompt 형태로 반환한다.
+   */
+  getPromptHints(limit = 50): string {
+    const db = getDatabase()
+    const words = db
+      .select({ word: dictionary.word })
+      .from(dictionary)
+      .orderBy(desc(dictionary.usageCount))
+      .limit(limit)
+      .all()
+
+    return words.map((w) => w.word).join(', ')
+  }
+
+  dispose(): void {
+    logger.info('DictionaryService disposed')
+  }
+
+  private _toEntry(row: Dictionary): DictionaryEntry {
+    return {
+      id: row.id,
+      word: row.word,
+      pronunciation: row.pronunciation,
+      category: row.category as DictionaryEntry['category'],
+      usageCount: row.usageCount,
+      lastUsedAt: row.lastUsedAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }
+  }
+}
+
+let instance: DictionaryService | null = null
+
+export function getDictionaryService(): DictionaryService {
+  if (!instance) {
+    instance = new DictionaryService()
+  }
+  return instance
+}