readshell 0.1.0

package/dist/index.js

@@ -0,0 +1,1656 @@
+#!/usr/bin/env node
+
+// src/cli/parser.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/services/BookService.ts
+import { resolve } from "path";
+import { existsSync as existsSync2, statSync } from "fs";
+import { nanoid } from "nanoid";
+
+// src/db/client.ts
+import Database from "better-sqlite3";
+
+// src/config/paths.ts
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync, existsSync } from "fs";
+function getAppDataDir() {
+  const platform = process.platform;
+  let configDir;
+  if (platform === "darwin") {
+    configDir = join(homedir(), "Library", "Application Support", "readshell");
+  } else if (platform === "win32") {
+    configDir = join(process.env["APPDATA"] || join(homedir(), "AppData", "Roaming"), "readshell");
+  } else {
+    configDir = join(process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config"), "readshell");
+  }
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  return configDir;
+}
+function getDbPath() {
+  return join(getAppDataDir(), "readshell.db");
+}
+
+// src/utils/logger.ts
+var isDebug = process.env["DEBUG"] === "1" || process.env["DEBUG"] === "true";
+var logger = {
+  debug: (...args) => {
+    if (isDebug) {
+      console.error("[DEBUG]", ...args);
+    }
+  },
+  info: (...args) => {
+    console.error("[INFO]", ...args);
+  },
+  warn: (...args) => {
+    console.error("[WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[ERROR]", ...args);
+  }
+};
+
+// src/db/client.ts
+var db = null;
+function getDb() {
+  if (!db) {
+    const dbPath = getDbPath();
+    logger.debug(`\u6570\u636E\u5E93\u8DEF\u5F84: ${dbPath}`);
+    db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+  }
+  return db;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+    logger.debug("\u6570\u636E\u5E93\u8FDE\u63A5\u5DF2\u5173\u95ED");
+  }
+}
+process.on("exit", () => closeDb());
+process.on("SIGINT", () => {
+  closeDb();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  closeDb();
+  process.exit(0);
+});
+
+// src/db/models/Book.ts
+var BookModel = class {
+  /**
+   * 插入新书
+   */
+  insert(book) {
+    const db2 = getDb();
+    db2.prepare(`
+      INSERT INTO books (id, title, author, file_path, format, file_hash, file_size, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(book.id, book.title, book.author, book.file_path, book.format, book.file_hash, book.file_size, book.created_at);
+  }
+  /**
+   * 通过 ID 获取书籍
+   */
+  findById(id) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM books WHERE id = ?").get(id);
+  }
+  /**
+   * 通过文件 hash 查找（去重用）
+   */
+  findByHash(hash) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM books WHERE file_hash = ?").get(hash);
+  }
+  /**
+   * 模糊搜索书名
+   */
+  searchByTitle(keyword) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM books WHERE title LIKE ? ORDER BY created_at DESC").all(`%${keyword}%`);
+  }
+  /**
+   * 获取所有书籍
+   */
+  findAll() {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM books ORDER BY created_at DESC").all();
+  }
+  /**
+   * 删除书籍
+   */
+  delete(id) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM books WHERE id = ?").run(id);
+  }
+};
+
+// src/db/models/Chapter.ts
+var ChapterModel = class {
+  /**
+   * 批量插入章节索引
+   */
+  insertMany(chapters) {
+    const db2 = getDb();
+    const stmt = db2.prepare(`
+      INSERT OR REPLACE INTO chapter_index (book_id, chapter_no, title, byte_offset)
+      VALUES (?, ?, ?, ?)
+    `);
+    db2.transaction(() => {
+      for (const chapter of chapters) {
+        stmt.run(chapter.book_id, chapter.chapter_no, chapter.title, chapter.byte_offset);
+      }
+    })();
+  }
+  /**
+   * 获取指定书籍的所有章节
+   */
+  findByBookId(bookId) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM chapter_index WHERE book_id = ? ORDER BY chapter_no").all(bookId);
+  }
+  /**
+   * 获取指定章节
+   */
+  findChapter(bookId, chapterNo) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM chapter_index WHERE book_id = ? AND chapter_no = ?").get(bookId, chapterNo);
+  }
+  /**
+   * 获取书籍章节总数
+   */
+  getChapterCount(bookId) {
+    const db2 = getDb();
+    const result = db2.prepare("SELECT COUNT(*) as count FROM chapter_index WHERE book_id = ?").get(bookId);
+    return result.count;
+  }
+  /**
+   * 删除指定书籍的章节索引
+   */
+  deleteByBookId(bookId) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM chapter_index WHERE book_id = ?").run(bookId);
+  }
+};
+
+// src/db/models/Recent.ts
+var RecentModel = class {
+  /**
+   * 记录打开（插入或更新计数）
+   */
+  recordOpen(bookId) {
+    const db2 = getDb();
+    const now = Date.now();
+    db2.prepare(`
+      INSERT INTO recent_reads (book_id, opened_at, open_count)
+      VALUES (?, ?, 1)
+      ON CONFLICT(book_id) DO UPDATE SET
+        opened_at = excluded.opened_at,
+        open_count = open_count + 1
+    `).run(bookId, now);
+  }
+  /**
+   * 获取最近阅读列表（按时间倒序）
+   */
+  getRecent(limit = 20) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM recent_reads ORDER BY opened_at DESC LIMIT ?").all(limit);
+  }
+  /**
+   * 删除记录
+   */
+  delete(bookId) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM recent_reads WHERE book_id = ?").run(bookId);
+  }
+};
+
+// src/db/models/Progress.ts
+var ProgressModel = class {
+  /**
+   * 保存或更新阅读进度
+   */
+  upsert(progress) {
+    const db2 = getDb();
+    db2.prepare(`
+      INSERT INTO reading_progress (book_id, chapter_no, byte_offset, percent, updated_at, opened_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(book_id) DO UPDATE SET
+        chapter_no = excluded.chapter_no,
+        byte_offset = excluded.byte_offset,
+        percent = excluded.percent,
+        updated_at = excluded.updated_at,
+        opened_at = excluded.opened_at
+    `).run(progress.book_id, progress.chapter_no, progress.byte_offset, progress.percent, progress.updated_at, progress.opened_at);
+  }
+  /**
+   * 获取指定书籍的阅读进度
+   */
+  findByBookId(bookId) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM reading_progress WHERE book_id = ?").get(bookId);
+  }
+  /**
+   * 获取最近打开的书籍进度（用于 resume）
+   */
+  getLastOpened() {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM reading_progress ORDER BY opened_at DESC LIMIT 1").get();
+  }
+  /**
+   * 删除指定书籍的进度
+   */
+  delete(bookId) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM reading_progress WHERE book_id = ?").run(bookId);
+  }
+};
+
+// src/parsers/TxtParser.ts
+import { readFileSync } from "fs";
+import { detect } from "chardet";
+import iconv from "iconv-lite";
+var CHAPTER_PATTERNS = [
+  /^第[零一二三四五六七八九十百千万\d]+[章节回卷集部篇]/m,
+  /^Chapter\s+\d+/im,
+  /^CHAPTER\s+\d+/m,
+  /^第\s*\d+\s*[章节回]/m
+];
+async function parseTxt(filePath) {
+  const buffer = readFileSync(filePath);
+  const encoding = detect(buffer) || "utf-8";
+  logger.debug(`\u68C0\u6D4B\u5230\u7F16\u7801: ${encoding}`);
+  const content = encoding.toLowerCase() === "utf-8" ? buffer.toString("utf-8") : iconv.decode(buffer, encoding);
+  const title = extractTitle(filePath);
+  const chapters = extractChapters(content);
+  return {
+    title,
+    author: null,
+    content,
+    chapters
+  };
+}
+function extractTitle(filePath) {
+  const basename = filePath.split("/").pop() || filePath;
+  return basename.replace(/\.txt$/i, "").trim() || "\u672A\u547D\u540D";
+}
+function extractChapters(content) {
+  const chapters = [];
+  const lines = content.split("\n");
+  let byteOffset = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    for (const pattern of CHAPTER_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        chapters.push({
+          title: trimmed,
+          byteOffset
+        });
+        break;
+      }
+    }
+    byteOffset += Buffer.byteLength(line + "\n", "utf-8");
+  }
+  logger.debug(`\u68C0\u6D4B\u5230 ${chapters.length} \u4E2A\u7AE0\u8282`);
+  return chapters;
+}
+
+// src/parsers/EpubParser.ts
+import { EPub } from "epub2";
+import { convert } from "html-to-text";
+async function parseEpub(filePath) {
+  logger.debug(`\u5F00\u59CB\u89E3\u6790 EPUB: ${filePath}`);
+  const epub = await openEpub(filePath);
+  const title = epub.metadata.title || "\u672A\u77E5\u4E66\u540D";
+  const author = epub.metadata.creator || null;
+  const chapters = [];
+  let fullContent = "";
+  let currentByteOffset = 0;
+  for (const chapterRef of epub.flow) {
+    if (!chapterRef.id) continue;
+    try {
+      const htmlText = await getChapterText(epub, chapterRef.id);
+      const plainText = convert(htmlText, {
+        wordwrap: false,
+        selectors: [
+          // 忽略图片和链接
+          { selector: "img", format: "skip" },
+          { selector: "a", options: { ignoreHref: true } }
+        ]
+      });
+      if (!plainText.trim()) continue;
+      const chapterTitle = chapterRef.title || "\u65E0\u6807\u9898\u7AE0\u8282";
+      chapters.push({
+        title: chapterTitle,
+        byteOffset: currentByteOffset
+      });
+      const chapterContent = `
+
+${chapterTitle}
+
+${plainText}
+`;
+      fullContent += chapterContent;
+      currentByteOffset += Buffer.byteLength(chapterContent, "utf-8");
+    } catch (err) {
+      logger.debug(`\u8B66\u544A: \u8BFB\u53D6\u7AE0\u8282 ${chapterRef.id} \u5931\u8D25`, err);
+    }
+  }
+  return {
+    title,
+    author,
+    content: fullContent,
+    chapters
+  };
+}
+function openEpub(filePath) {
+  return new Promise((resolve2, reject) => {
+    const epub = new EPub(filePath);
+    epub.on("error", (err) => reject(err));
+    epub.on("end", () => resolve2(epub));
+    epub.parse();
+  });
+}
+function getChapterText(epub, chapterId) {
+  return new Promise((resolve2, reject) => {
+    epub.getChapter(chapterId, (err, text) => {
+      if (err) return reject(err);
+      resolve2(text);
+    });
+  });
+}
+
+// src/parsers/index.ts
+async function parseFile(filePath, format) {
+  switch (format) {
+    case "txt":
+      return parseTxt(filePath);
+    case "epub":
+      return parseEpub(filePath);
+    default:
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u683C\u5F0F: ${format}`);
+  }
+}
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+async function computeFileHash(filePath) {
+  const buffer = readFileSync2(filePath);
+  const hash = createHash("sha256");
+  hash.update(buffer);
+  return hash.digest("hex");
+}
+
+// src/services/BookService.ts
+var BookService = class {
+  bookModel = new BookModel();
+  chapterModel = new ChapterModel();
+  recentModel = new RecentModel();
+  progressModel = new ProgressModel();
+  /**
+   * 导入书籍文件
+   */
+  async importBook(filePath) {
+    const absPath = resolve(filePath);
+    if (!existsSync2(absPath)) {
+      throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${absPath}`);
+    }
+    const format = this.detectFormat(absPath);
+    if (!format) {
+      throw new Error("\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u683C\u5F0F\u3002\u76EE\u524D\u652F\u6301: .txt, .epub");
+    }
+    const fileHash = await computeFileHash(absPath);
+    const existing = this.bookModel.findByHash(fileHash);
+    if (existing) {
+      logger.debug(`\u6587\u4EF6\u5DF2\u5B58\u5728: ${existing.title} (${existing.id})`);
+      return existing;
+    }
+    const parsed = await parseFile(absPath, format);
+    const stats = statSync(absPath);
+    const book = {
+      id: nanoid(),
+      title: parsed.title,
+      author: parsed.author || null,
+      file_path: absPath,
+      format,
+      file_hash: fileHash,
+      file_size: stats.size,
+      created_at: Date.now()
+    };
+    this.bookModel.insert(book);
+    if (parsed.chapters.length > 0) {
+      this.chapterModel.insertMany(
+        parsed.chapters.map((ch, idx) => ({
+          book_id: book.id,
+          chapter_no: idx,
+          title: ch.title,
+          byte_offset: ch.byteOffset
+        }))
+      );
+    }
+    logger.debug(`\u5BFC\u5165\u6210\u529F: ${book.title}`);
+    return book;
+  }
+  /**
+   * 查找书籍（ID 或模糊匹配书名）
+   */
+  findBook(target) {
+    const byId = this.bookModel.findById(target);
+    if (byId) return byId;
+    const results = this.bookModel.searchByTitle(target);
+    return results[0];
+  }
+  /**
+   * 搜索书籍
+   */
+  searchBooks(keyword) {
+    return this.bookModel.searchByTitle(keyword);
+  }
+  /**
+   * 获取所有书籍
+   */
+  getAllBooks() {
+    return this.bookModel.findAll();
+  }
+  /**
+   * 删除书籍及相关数据
+   */
+  deleteBook(id) {
+    this.chapterModel.deleteByBookId(id);
+    this.progressModel.delete(id);
+    this.recentModel.delete(id);
+    this.bookModel.delete(id);
+  }
+  /**
+   * 检测文件格式
+   */
+  detectFormat(filePath) {
+    const ext = filePath.toLowerCase().split(".").pop();
+    if (ext === "txt") return "txt";
+    if (ext === "epub") return "epub";
+    return null;
+  }
+};
+
+// src/cli/commands/import.ts
+var importCommand = {
+  command: "import <file>",
+  describe: "\u5BFC\u5165\u672C\u5730\u6587\u4EF6\u5230\u4E66\u67B6",
+  builder: (yargs2) => {
+    return yargs2.positional("file", {
+      describe: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u652F\u6301 .txt / .epub\uFF09",
+      type: "string",
+      demandOption: true
+    });
+  },
+  handler: async (argv) => {
+    try {
+      const bookService = new BookService();
+      const book = await bookService.importBook(argv.file);
+      console.log(`\u2713 \u5DF2\u5BFC\u5165: ${book.title} (${book.id})`);
+    } catch (error) {
+      logger.error("\u5BFC\u5165\u5931\u8D25:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// src/services/ProgressService.ts
+var ProgressService = class {
+  progressModel = new ProgressModel();
+  recentModel = new RecentModel();
+  /**
+   * 保存阅读进度（退出时调用）
+   */
+  saveProgress(bookId, chapterNo, byteOffset, percent) {
+    const now = Date.now();
+    this.progressModel.upsert({
+      book_id: bookId,
+      chapter_no: chapterNo,
+      byte_offset: byteOffset,
+      percent,
+      updated_at: now,
+      opened_at: now
+    });
+    this.recentModel.recordOpen(bookId);
+    logger.debug(`\u8FDB\u5EA6\u5DF2\u4FDD\u5B58: book=${bookId}, chapter=${chapterNo}, offset=${byteOffset}, ${(percent * 100).toFixed(1)}%`);
+  }
+  /**
+   * 获取指定书籍的阅读进度（resume 时调用）
+   */
+  getProgress(bookId) {
+    return this.progressModel.findByBookId(bookId);
+  }
+  /**
+   * 获取最近打开的书籍进度（启动时调用，决定 resume 哪本书）
+   */
+  getLastOpenedBook() {
+    return this.progressModel.getLastOpened();
+  }
+};
+
+// src/ui/renderApp.ts
+import React6 from "react";
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useState as useState6 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+
+// src/ui/pages/ResumePage.tsx
+import { useEffect, useState } from "react";
+import { Box, Text, useApp } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ResumePage({ onNavigate }) {
+  const { exit } = useApp();
+  const [checking, setChecking] = useState(true);
+  useEffect(() => {
+    const progressService = new ProgressService();
+    const lastProgress = progressService.getLastOpenedBook();
+    if (!lastProgress) {
+      setChecking(false);
+      return;
+    }
+    const bookModel = new BookModel();
+    const book = bookModel.findById(lastProgress.book_id);
+    if (!book) {
+      setChecking(false);
+      return;
+    }
+    onNavigate("reader", book.id, lastProgress.byte_offset);
+  }, [onNavigate]);
+  if (checking) {
+    return /* @__PURE__ */ jsx(Box, { padding: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u{1F4D6} \u68C0\u67E5\u9605\u8BFB\u8BB0\u5F55..." }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u{1F4D6} ReadShell \u2014 \u7EC8\u7AEF\u5185\u8F7B\u9605\u8BFB" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u6682\u65E0\u9605\u8BFB\u8BB0\u5F55\u3002" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u4F7F\u7528 novel import <file> \u5BFC\u5165\u4E00\u672C\u4E66\u5F00\u59CB\u9605\u8BFB\u3002" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u6309 q \u9000\u51FA" }) })
+    ] })
+  ] });
+}
+
+// src/ui/pages/LibraryPage.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box2, Text as Text2, useApp as useApp2, useInput } from "ink";
+
+// src/services/RecentService.ts
+var RecentService = class {
+  recentModel = new RecentModel();
+  bookModel = new BookModel();
+  /**
+   * 获取最近阅读的书籍列表（包含书籍详情）
+   */
+  getRecentBooks(limit = 20) {
+    const recentRecords = this.recentModel.getRecent(limit);
+    return recentRecords.map((record) => this.bookModel.findById(record.book_id)).filter((book) => book !== void 0);
+  }
+  /**
+   * 记录打开事件
+   */
+  recordOpen(bookId) {
+    this.recentModel.recordOpen(bookId);
+  }
+};
+
+// src/ui/pages/LibraryPage.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function LibraryPage({ onNavigate }) {
+  const { exit } = useApp2();
+  const [books, setBooks] = useState2([]);
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [loading, setLoading] = useState2(true);
+  const isRawModeSupported = process.stdin.isTTY ?? false;
+  useEffect2(() => {
+    const recentService = new RecentService();
+    const recentBooks = recentService.getRecentBooks();
+    if (recentBooks.length > 0) {
+      setBooks(recentBooks);
+    } else {
+      const bookService = new BookService();
+      setBooks(bookService.getAllBooks());
+    }
+    setLoading(false);
+  }, []);
+  useInput((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (books.length === 0) return;
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((prev) => Math.max(prev - 1, 0));
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((prev) => Math.min(prev + 1, books.length - 1));
+    }
+    if (key.backspace || key.delete || input === "d" || input === "x") {
+      const selected = books[selectedIndex];
+      if (selected) {
+        const bookService = new BookService();
+        bookService.deleteBook(selected.id);
+        setBooks((prev) => {
+          const next = prev.filter((b) => b.id !== selected.id);
+          if (selectedIndex >= next.length) {
+            setSelectedIndex(Math.max(0, next.length - 1));
+          }
+          return next;
+        });
+      }
+      return;
+    }
+    if (key.return) {
+      const selected = books[selectedIndex];
+      if (selected) {
+        const progressService = new ProgressService();
+        const progress = progressService.getProgress(selected.id);
+        onNavigate("reader", selected.id, progress?.byte_offset ?? 0);
+      }
+    }
+  }, { isActive: isRawModeSupported });
+  if (loading) {
+    return /* @__PURE__ */ jsx2(Box2, { padding: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u{1F4DA} \u52A0\u8F7D\u4E66\u67B6..." }) });
+  }
+  if (books.length === 0) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: "\u{1F4DA} \u4E66\u67B6" }),
+      /* @__PURE__ */ jsxs2(Box2, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u4E66\u67B6\u4E3A\u7A7A\u3002\u4F7F\u7528 novel import <file> \u5BFC\u5165\u4F60\u7684\u7B2C\u4E00\u672C\u4E66\u3002" }),
+        /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u6309 q \u9000\u51FA" }) })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
+      "\u{1F4DA} \u4E66\u67B6 (",
+      books.length,
+      " \u672C)"
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "  \u2191\u2193/jk \u9009\u62E9 \xB7 Enter \u6253\u5F00 \xB7 d/x \u5220\u9664 \xB7 q \u9000\u51FA" }),
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: books.map((book, index) => {
+      const isSelected = index === selectedIndex;
+      return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "space-between", children: /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsxs2(
+          Text2,
+          {
+            color: isSelected ? "cyan" : void 0,
+            bold: isSelected,
+            children: [
+              isSelected ? "\u25B8 " : "  ",
+              book.title
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "  (",
+          book.format,
+          ")"
+        ] })
+      ] }) }, book.id);
+    }) })
+  ] });
+}
+
+// src/ui/pages/ReaderPage.tsx
+import { useState as useState5, useEffect as useEffect4, useRef } from "react";
+import { Box as Box6, Text as Text6, useApp as useApp3, useStdout } from "ink";
+
+// src/ui/components/TextRenderer.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function renderLineWithHighlight(line) {
+  if (!line) return /* @__PURE__ */ jsx3(Text3, { children: " " });
+  const regex = /(「.*?」|“.*?”|『.*?』|《.*?》)/g;
+  const parts = line.split(regex);
+  return /* @__PURE__ */ jsx3(Text3, { children: parts.map((part, index) => {
+    if (regex.test(part)) {
+    }
+    const isHighlight = index % 2 === 1;
+    if (isHighlight) {
+      return /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: part }, index);
+    }
+    return /* @__PURE__ */ jsx3(Text3, { children: part }, index);
+  }) });
+}
+function TextRenderer({ lines, height }) {
+  const displayLines = [...lines];
+  if (height && displayLines.length < height) {
+    const padding = height - displayLines.length;
+    for (let i = 0; i < padding; i++) {
+      displayLines.push("");
+    }
+  }
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: displayLines.map((line, index) => /* @__PURE__ */ jsx3(Box3, { children: renderLineWithHighlight(line) }, index)) });
+}
+
+// src/ui/components/StatusBar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function StatusBar({
+  bookTitle,
+  chapterTitle,
+  percent,
+  currentPage,
+  totalPages,
+  remainingTime
+}) {
+  const displayPercent = (percent * 100).toFixed(1);
+  const titleDisplay = chapterTitle ? `${bookTitle} \xB7 ${chapterTitle}` : bookTitle;
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", justifyContent: "space-between", borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs3(Text4, { color: "gray", children: [
+      "\u{1F4D6} ",
+      titleDisplay
+    ] }) }),
+    /* @__PURE__ */ jsxs3(Box4, { children: [
+      remainingTime && /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+        "\u9884\u8BA1\u5269\u4F59 ",
+        remainingTime,
+        "  "
+      ] }),
+      /* @__PURE__ */ jsxs3(Text4, { color: "gray", children: [
+        currentPage,
+        "/",
+        totalPages
+      ] }),
+      /* @__PURE__ */ jsxs3(Text4, { color: "gray", children: [
+        displayPercent,
+        "%"
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "q\u9000\u51FA" })
+    ] })
+  ] });
+}
+
+// src/ui/components/ChapterNav.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function ChapterNav({
+  chapters,
+  bookmarks,
+  currentChapterId,
+  termHeight,
+  onSelect,
+  onClose
+}) {
+  const [activeTab, setActiveTab] = useState3("chapters");
+  const isBookmarks = activeTab === "bookmarks";
+  const currentList = isBookmarks ? bookmarks : chapters;
+  const initialIndex = currentChapterId && !isBookmarks ? Math.max(
+    0,
+    chapters.findIndex((c) => c.id === currentChapterId)
+  ) : 0;
+  const [selectedIndex, setSelectedIndex] = useState3(initialIndex);
+  useEffect3(() => {
+    setSelectedIndex(isBookmarks ? 0 : initialIndex);
+  }, [activeTab, initialIndex, isBookmarks]);
+  const pageSize = Math.max(5, termHeight - 6);
+  const windowStart = Math.max(0, Math.floor(selectedIndex / pageSize) * pageSize);
+  const visibleItems = currentList.slice(windowStart, windowStart + pageSize);
+  const isRawModeSupported = process.stdin.isTTY ?? false;
+  useInput2(
+    (input, key) => {
+      if (key.escape || input === "q") {
+        onClose();
+        return;
+      }
+      if (key.tab) {
+        setActiveTab((prev) => prev === "chapters" ? "bookmarks" : "chapters");
+        return;
+      }
+      if (key.return) {
+        if (currentList[selectedIndex]) {
+          onSelect(currentList[selectedIndex].byte_offset);
+        }
+        return;
+      }
+      if (key.upArrow || input === "k") {
+        setSelectedIndex((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow || input === "j") {
+        setSelectedIndex((prev) => Math.min(currentList.length - 1, prev + 1));
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
+  return /* @__PURE__ */ jsxs4(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "green",
+      paddingX: 2,
+      paddingY: 1,
+      width: "80%",
+      alignSelf: "center",
+      marginTop: 2,
+      children: [
+        /* @__PURE__ */ jsxs4(Box5, { justifyContent: "space-between", marginBottom: 1, children: [
+          /* @__PURE__ */ jsxs4(Box5, { children: [
+            /* @__PURE__ */ jsx5(Text5, { bold: true, color: activeTab === "chapters" ? "green" : "gray", children: "[\u5168\u90E8\u7AE0\u8282] " }),
+            /* @__PURE__ */ jsx5(Text5, { bold: true, color: activeTab === "bookmarks" ? "green" : "gray", children: "[\u6211\u7684\u4E66\u7B7E]" })
+          ] }),
+          /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Enter \u8DF3\u8F6C \xB7 Tab \u5207\u6362 \xB7 Esc/q \u5173\u95ED" })
+        ] }),
+        visibleItems.length === 0 ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u6CA1\u6709\u8BB0\u5F55" }) : visibleItems.map((item, idx) => {
+          const actualIndex = windowStart + idx;
+          const isSelected = actualIndex === selectedIndex;
+          return /* @__PURE__ */ jsxs4(
+            Text5,
+            {
+              color: isSelected ? "green" : void 0,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u25B6 " : "  ",
+                item.title
+              ]
+            },
+            item.id
+          );
+        }),
+        /* @__PURE__ */ jsx5(Box5, { marginTop: 1, justifyContent: "flex-end", children: /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+          "\u7B2C ",
+          Math.floor(selectedIndex / pageSize) + 1,
+          " / ",
+          Math.ceil(currentList.length / pageSize) || 1,
+          " \u9875"
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/ui/hooks/useReader.ts
+import { useState as useState4, useCallback, useMemo } from "react";
+function useReader(pages, initialByteOffset) {
+  const initialPage = useMemo(() => {
+    if (!initialByteOffset || pages.length === 0) return 0;
+    let targetPage = 0;
+    for (let i = 0; i < pages.length; i++) {
+      if (pages[i].byteOffset <= initialByteOffset) {
+        targetPage = i;
+      } else {
+        break;
+      }
+    }
+    return targetPage;
+  }, [pages, initialByteOffset]);
+  const [state, setState] = useState4({
+    currentPage: initialPage,
+    totalPages: pages.length
+  });
+  const nextPage = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      currentPage: Math.min(prev.currentPage + 1, prev.totalPages - 1)
+    }));
+  }, []);
+  const prevPage = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      currentPage: Math.max(prev.currentPage - 1, 0)
+    }));
+  }, []);
+  const goToPage = useCallback((pageNum) => {
+    setState((prev) => ({
+      ...prev,
+      currentPage: Math.max(0, Math.min(pageNum, prev.totalPages - 1))
+    }));
+  }, []);
+  const goToOffset = useCallback((byteOffset) => {
+    let targetPage = 0;
+    for (let i = 0; i < pages.length; i++) {
+      if (pages[i].byteOffset <= byteOffset) {
+        targetPage = i;
+      } else {
+        break;
+      }
+    }
+    setState((prev) => ({
+      ...prev,
+      currentPage: targetPage
+    }));
+  }, [pages]);
+  const getCurrentPage = useCallback(() => {
+    return pages[state.currentPage];
+  }, [state.currentPage, pages]);
+  const getCurrentOffset = useCallback(() => {
+    return pages[state.currentPage]?.byteOffset ?? 0;
+  }, [state.currentPage, pages]);
+  const getPercent = useCallback(() => {
+    if (state.totalPages === 0) return 0;
+    return (state.currentPage + 1) / state.totalPages;
+  }, [state.currentPage, state.totalPages]);
+  const isFirstPage = state.currentPage === 0;
+  const isLastPage = state.currentPage === state.totalPages - 1;
+  return {
+    ...state,
+    nextPage,
+    prevPage,
+    goToPage,
+    goToOffset,
+    getCurrentPage,
+    getCurrentOffset,
+    getPercent,
+    isFirstPage,
+    isLastPage
+  };
+}
+
+// src/ui/hooks/useKeyboard.ts
+import { useInput as useInput3 } from "ink";
+function useKeyboard(handlers, isActive = true) {
+  const isRawModeSupported = process.stdin.isTTY ?? false;
+  const shouldListen = isRawModeSupported && isActive;
+  useInput3((input, key) => {
+    if (input === " " || input === "j" || key.downArrow || input === "f") {
+      handlers.onNext?.();
+    }
+    if (input === "k" || key.upArrow || input === "b") {
+      handlers.onPrev?.();
+    }
+    if (input === "q") {
+      handlers.onQuit?.();
+    }
+    if (input === "c") {
+      handlers.onChapterList?.();
+    }
+    if (input === "?") {
+      handlers.onHelp?.();
+    }
+    if (handlers.onBossKey && (key.escape || input === "esc" || input === "b" || input === "B")) {
+      handlers.onBossKey?.();
+    }
+    if (handlers.onBookmarkAdd && (input === "m" || input === "M")) {
+      handlers.onBookmarkAdd?.();
+    }
+  }, { isActive: shouldListen });
+}
+
+// src/utils/stringWidth.ts
+function getStringWidth(str) {
+  let width = 0;
+  for (const char of str) {
+    width += isFullWidth(char) ? 2 : 1;
+  }
+  return width;
+}
+function isFullWidth(char) {
+  const code = char.codePointAt(0);
+  if (code === void 0) return false;
+  return (
+    // CJK 统一表意字符
+    code >= 19968 && code <= 40959 || // CJK 统一表意字符扩展 A
+    code >= 13312 && code <= 19903 || // CJK 统一表意字符扩展 B
+    code >= 131072 && code <= 173791 || // CJK 兼容表意字符
+    code >= 63744 && code <= 64255 || // 全角 ASCII、全角标点
+    code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || // CJK 标点符号
+    code >= 12288 && code <= 12351 || // 日文平假名/片假名
+    code >= 12352 && code <= 12543 || // 韩文音节
+    code >= 44032 && code <= 55215
+  );
+}
+
+// src/utils/paginate.ts
+function paginate(text, width, height) {
+  const pages = [];
+  const rawLines = text.split("\n");
+  const wrappedLines = [];
+  let currentOffset = 0;
+  for (const rawLine of rawLines) {
+    const wrapped = wrapLine(rawLine, width);
+    for (const line of wrapped) {
+      wrappedLines.push({ text: line, byteOffset: currentOffset });
+    }
+    currentOffset += Buffer.byteLength(rawLine + "\n", "utf-8");
+  }
+  for (let i = 0; i < wrappedLines.length; i += height) {
+    const pageLines = wrappedLines.slice(i, i + height);
+    pages.push({
+      lines: pageLines.map((l) => l.text),
+      byteOffset: pageLines[0]?.byteOffset ?? 0
+    });
+  }
+  return pages;
+}
+function wrapLine(line, width) {
+  if (line.length === 0) return [""];
+  const result = [];
+  let currentLine = "";
+  let currentWidth = 0;
+  for (const char of line) {
+    const charWidth = getStringWidth(char);
+    if (currentWidth + charWidth > width) {
+      result.push(currentLine);
+      currentLine = char;
+      currentWidth = charWidth;
+    } else {
+      currentLine += char;
+      currentWidth += charWidth;
+    }
+  }
+  if (currentLine.length > 0) {
+    result.push(currentLine);
+  }
+  return result.length > 0 ? result : [""];
+}
+
+// src/utils/encoding.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { detect as detect2 } from "chardet";
+import iconv2 from "iconv-lite";
+function readFileWithEncoding(filePath) {
+  const buffer = readFileSync3(filePath);
+  const encoding = detect2(buffer) || "utf-8";
+  if (encoding.toLowerCase() === "utf-8" || encoding.toLowerCase() === "ascii") {
+    return buffer.toString("utf-8");
+  }
+  return iconv2.decode(buffer, encoding);
+}
+
+// src/services/ChapterService.ts
+var ChapterService = class {
+  chapterModel = new ChapterModel();
+  /**
+   * 获取指定书籍的所有章节
+   */
+  getChapters(bookId) {
+    return this.chapterModel.findByBookId(bookId);
+  }
+  /**
+   * 获取指定章节信息
+   */
+  getChapter(bookId, chapterNo) {
+    return this.chapterModel.findChapter(bookId, chapterNo);
+  }
+  /**
+   * 获取章节总数
+   */
+  getChapterCount(bookId) {
+    return this.chapterModel.getChapterCount(bookId);
+  }
+  /**
+   * 获取指定书籍下的所有章节
+   */
+  getChaptersByBookId(bookId) {
+    return this.chapterModel.findByBookId(bookId);
+  }
+  /**
+   * 根据 offset 查询当前所属章节（用于高亮当前所在章）
+   */
+  getChapterByOffset(bookId, byteOffset) {
+    const chapters = this.chapterModel.findByBookId(bookId);
+    if (chapters.length === 0) return void 0;
+    let current;
+    for (const chapter of chapters) {
+      if (chapter.byte_offset <= byteOffset) {
+        current = chapter;
+      } else {
+        break;
+      }
+    }
+    return current;
+  }
+};
+
+// src/db/models/Bookmark.ts
+var BookmarkModel = class {
+  /**
+   * 插入书签
+   */
+  insert(bookmark) {
+    const db2 = getDb();
+    db2.prepare(`
+      INSERT INTO bookmarks (book_id, title, byte_offset, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(bookmark.book_id, bookmark.title, bookmark.byte_offset, bookmark.created_at);
+  }
+  /**
+   * 获取指定书籍的所有书签
+   */
+  findByBookId(bookId) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM bookmarks WHERE book_id = ? ORDER BY created_at DESC").all(bookId);
+  }
+  /**
+   * 获取指定书签
+   */
+  findById(id) {
+    const db2 = getDb();
+    return db2.prepare("SELECT * FROM bookmarks WHERE id = ?").get(id);
+  }
+  /**
+   * 获取书籍书签总数
+   */
+  getCount(bookId) {
+    const db2 = getDb();
+    const result = db2.prepare("SELECT COUNT(*) as count FROM bookmarks WHERE book_id = ?").get(bookId);
+    return result.count;
+  }
+  /**
+   * 删除书签
+   */
+  delete(id) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM bookmarks WHERE id = ?").run(id);
+  }
+  /**
+   * 移除整本书的书签 (配合彻底清理书籍使用)
+   */
+  deleteByBookId(bookId) {
+    const db2 = getDb();
+    db2.prepare("DELETE FROM bookmarks WHERE book_id = ?").run(bookId);
+  }
+};
+
+// src/services/BookmarkService.ts
+var BookmarkService = class {
+  bookmarkModel;
+  constructor() {
+    this.bookmarkModel = new BookmarkModel();
+  }
+  /**
+   * 增加一条书签
+   * @param title 该书签展现给用户的文案（一句话大纲）
+   */
+  addBookmark(bookId, title, byteOffset) {
+    this.bookmarkModel.insert({
+      book_id: bookId,
+      title,
+      byte_offset: byteOffset,
+      created_at: Date.now()
+    });
+  }
+  /**
+   * 罗列该书全部的书签
+   */
+  getBookmarksByBookId(bookId) {
+    return this.bookmarkModel.findByBookId(bookId);
+  }
+  /**
+   * 删掉对应书签
+   */
+  removeBookmark(id) {
+    this.bookmarkModel.delete(id);
+  }
+};
+
+// src/utils/bossKey.ts
+function triggerBossKey() {
+  console.clear();
+  const fakeLog = `
+  VITE v5.2.8  ready in 213 ms
+
+  \u279C  Local:   http://localhost:5173/
+  \u279C  Network: use --host to expose
+  \u279C  press h + enter to show help
+`;
+  console.log(fakeLog);
+  process.exit(0);
+}
+
+// src/utils/time.ts
+function estimateReadingTime(charCount, isChinese = true) {
+  const charsPerMinute = isChinese ? 500 : 1250;
+  return Math.ceil(charCount / charsPerMinute);
+}
+function formatReadingTime(minutes) {
+  if (minutes < 60) {
+    return `${minutes} \u5206\u949F`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return mins > 0 ? `${hours} \u5C0F\u65F6 ${mins} \u5206\u949F` : `${hours} \u5C0F\u65F6`;
+}
+
+// src/ui/pages/ReaderPage.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function ReaderContent({
+  book,
+  bookId,
+  pages,
+  initialByteOffset,
+  termHeight,
+  contentHeight
+}) {
+  const { exit } = useApp3();
+  const [chapterTitle, setChapterTitle] = useState5();
+  const [currentChapter, setCurrentChapter] = useState5();
+  const [showChapterNav, setShowChapterNav] = useState5(false);
+  const [allChapters, setAllChapters] = useState5([]);
+  const [allBookmarks, setAllBookmarks] = useState5([]);
+  const [toastMessage, setToastMessage] = useState5(null);
+  const progressServiceRef = useRef(new ProgressService());
+  const chapterServiceRef = useRef(new ChapterService());
+  const bookmarkServiceRef = useRef(new BookmarkService());
+  const reader = useReader(pages, initialByteOffset);
+  useEffect4(() => {
+    const currentOffset = reader.getCurrentOffset();
+    const chapter = chapterServiceRef.current.getChapterByOffset(bookId, currentOffset);
+    setCurrentChapter(chapter ?? void 0);
+    setChapterTitle(chapter?.title ?? void 0);
+  }, [reader.currentPage, bookId]);
+  useEffect4(() => {
+    const chaptersList = chapterServiceRef.current.getChaptersByBookId(bookId);
+    setAllChapters(chaptersList);
+    if (showChapterNav) {
+      setAllBookmarks(bookmarkServiceRef.current.getBookmarksByBookId(bookId));
+    }
+  }, [bookId, showChapterNav]);
+  const handleAddBookmark = () => {
+    const currentPageInfo = reader.getCurrentPage();
+    if (!currentPageInfo) return;
+    let markTitle = "\u65E0\u6807\u9898\u4E66\u7B7E";
+    for (const line of currentPageInfo.lines) {
+      const stripped = line.trim();
+      if (stripped.length > 0) {
+        markTitle = stripped.slice(0, 15) + (stripped.length > 15 ? "..." : "");
+        break;
+      }
+    }
+    const currentOffset = reader.getCurrentOffset();
+    bookmarkServiceRef.current.addBookmark(bookId, markTitle, currentOffset);
+    setToastMessage(`\u2713 \u589E\u52A0\u4E66\u7B7E: ${markTitle}`);
+    setTimeout(() => setToastMessage(null), 2e3);
+  };
+  useEffect4(() => {
+    return () => {
+      const offset = reader.getCurrentOffset();
+      const percent = reader.getPercent();
+      const chapter = chapterServiceRef.current.getChapterByOffset(bookId, offset);
+      const chapterNo = chapter?.chapter_no ?? 0;
+      progressServiceRef.current.saveProgress(bookId, chapterNo, offset, percent);
+      logger.debug(`\u8FDB\u5EA6\u5DF2\u4FDD\u5B58: offset=${offset}, ${(percent * 100).toFixed(1)}%`);
+    };
+  }, [bookId, reader]);
+  useKeyboard(
+    {
+      onNext: () => reader.nextPage(),
+      onPrev: () => reader.prevPage(),
+      onQuit: () => exit(),
+      onChapterList: () => setShowChapterNav(true),
+      onBossKey: () => triggerBossKey(),
+      onBookmarkAdd: handleAddBookmark
+    },
+    !showChapterNav
+    // 如果浮层显示，则停止普通的阅读快捷键
+  );
+  const currentPage = reader.getCurrentPage();
+  const currentLines = currentPage?.lines ?? [];
+  const calculatedContentHeight = Math.max(1, termHeight - 2);
+  const totalChars = (book.file_size ?? 0) / 3;
+  const remainingChars = Math.max(0, totalChars * (1 - reader.getPercent()));
+  const remainingMinutes = estimateReadingTime(remainingChars, true);
+  const remainingTimeStr = formatReadingTime(remainingMinutes);
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", height: termHeight, children: !showChapterNav ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+    /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", flexGrow: 1, paddingX: 1, children: /* @__PURE__ */ jsx6(TextRenderer, { lines: currentLines, height: calculatedContentHeight }) }),
+    /* @__PURE__ */ jsx6(
+      StatusBar,
+      {
+        bookTitle: book.title,
+        percent: reader.getPercent(),
+        chapterTitle,
+        currentPage: reader.currentPage + 1,
+        totalPages: reader.totalPages,
+        remainingTime: remainingTimeStr
+      }
+    ),
+    toastMessage && /* @__PURE__ */ jsx6(Box6, { alignSelf: "flex-end", marginTop: -2, marginRight: 1, borderStyle: "round", borderColor: "green", paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "green", children: toastMessage }) })
+  ] }) : /* @__PURE__ */ jsx6(
+    ChapterNav,
+    {
+      chapters: allChapters,
+      bookmarks: allBookmarks,
+      currentChapterId: currentChapter?.id,
+      termHeight,
+      onSelect: (offset) => {
+        reader.goToOffset(offset);
+        setShowChapterNav(false);
+      },
+      onClose: () => setShowChapterNav(false)
+    }
+  ) });
+}
+function ReaderPage({ bookId, initialByteOffset, onNavigate: _onNavigate }) {
+  const { exit } = useApp3();
+  const { stdout } = useStdout();
+  const [book, setBook] = useState5(null);
+  const [pages, setPages] = useState5(null);
+  const [error, setError] = useState5(null);
+  const termWidth = stdout?.columns ?? 80;
+  const termHeight = stdout?.rows ?? 24;
+  const contentHeight = Math.max(termHeight - 3, 5);
+  useEffect4(() => {
+    try {
+      const bookModel = new BookModel();
+      const bookRecord = bookModel.findById(bookId);
+      if (!bookRecord) {
+        setError(`\u4E66\u7C4D\u4E0D\u5B58\u5728: ${bookId}`);
+        return;
+      }
+      setBook(bookRecord);
+      const recentService = new RecentService();
+      recentService.recordOpen(bookId);
+      const content = readFileWithEncoding(bookRecord.file_path);
+      const paginatedPages = paginate(content, termWidth - 2, contentHeight);
+      setPages(paginatedPages);
+      logger.debug(`\u52A0\u8F7D\u5B8C\u6210: ${bookRecord.title}, ${paginatedPages.length} \u9875`);
+    } catch (err) {
+      setError(`\u52A0\u8F7D\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }, [bookId, termWidth, contentHeight]);
+  useKeyboard({
+    onQuit: () => exit()
+  });
+  if (error) {
+    return /* @__PURE__ */ jsxs5(Box6, { padding: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs5(Text6, { color: "red", children: [
+        "\u2717 ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u6309 q \u9000\u51FA" })
+    ] });
+  }
+  if (!book || !pages) {
+    return /* @__PURE__ */ jsx6(Box6, { padding: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u{1F4D6} \u6B63\u5728\u52A0\u8F7D..." }) });
+  }
+  return /* @__PURE__ */ jsx6(
+    ReaderContent,
+    {
+      book,
+      bookId,
+      pages,
+      initialByteOffset,
+      termHeight,
+      contentHeight
+    }
+  );
+}
+
+// src/ui/App.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ initialPage = "resume", bookId, initialByteOffset }) {
+  const [currentPage, setCurrentPage] = useState6(initialPage);
+  const [currentBookId, setCurrentBookId] = useState6(bookId);
+  const [currentByteOffset, setCurrentByteOffset] = useState6(initialByteOffset);
+  const navigateTo = (page, targetBookId, byteOffset) => {
+    setCurrentPage(page);
+    if (targetBookId) setCurrentBookId(targetBookId);
+    if (byteOffset !== void 0) setCurrentByteOffset(byteOffset);
+  };
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", width: "100%", children: [
+    currentPage === "resume" && /* @__PURE__ */ jsx7(ResumePage, { onNavigate: navigateTo }),
+    currentPage === "library" && /* @__PURE__ */ jsx7(LibraryPage, { onNavigate: navigateTo }),
+    currentPage === "reader" && currentBookId && /* @__PURE__ */ jsx7(
+      ReaderPage,
+      {
+        bookId: currentBookId,
+        initialByteOffset: currentByteOffset,
+        onNavigate: navigateTo
+      }
+    ),
+    currentPage === "reader" && !currentBookId && /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { color: "red", children: "\u9519\u8BEF: \u672A\u6307\u5B9A\u4E66\u7C4D" }) })
+  ] });
+}
+
+// src/ui/renderApp.ts
+function renderApp(options = {}) {
+  const { initialPage = "resume", bookId, initialByteOffset } = options;
+  const { waitUntilExit } = render(
+    React6.createElement(App, {
+      initialPage,
+      bookId,
+      initialByteOffset
+    })
+  );
+  waitUntilExit().catch(() => {
+    process.exit(0);
+  });
+}
+
+// src/cli/commands/resume.ts
+var resumeCommand = {
+  command: "resume",
+  describe: "\u6062\u590D\u4E0A\u6B21\u9605\u8BFB",
+  handler: async () => {
+    try {
+      const progressService = new ProgressService();
+      const lastProgress = progressService.getLastOpenedBook();
+      if (!lastProgress) {
+        console.log("\u{1F4DA} \u8FD8\u6CA1\u6709\u9605\u8BFB\u8BB0\u5F55\u3002\u4F7F\u7528 novel import <file> \u5BFC\u5165\u4E00\u672C\u4E66\u5F00\u59CB\u9605\u8BFB\u3002");
+        return;
+      }
+      const bookService = new BookService();
+      const book = bookService.findBook(lastProgress.book_id);
+      if (!book) {
+        console.log("\u{1F4DA} \u4E0A\u6B21\u9605\u8BFB\u7684\u4E66\u7C4D\u5DF2\u88AB\u5220\u9664\u3002\u4F7F\u7528 novel library \u67E5\u770B\u4E66\u67B6\u3002");
+        return;
+      }
+      logger.debug(`\u6062\u590D\u9605\u8BFB: ${book.title}, offset=${lastProgress.byte_offset}`);
+      renderApp({
+        initialPage: "reader",
+        bookId: lastProgress.book_id,
+        initialByteOffset: lastProgress.byte_offset
+      });
+    } catch (error) {
+      logger.error("\u6062\u590D\u9605\u8BFB\u5931\u8D25:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// src/cli/commands/open.ts
+var openCommand = {
+  command: "open <target>",
+  describe: "\u6253\u5F00\u6307\u5B9A\u4E66\u7C4D\uFF08ID \u6216\u4E66\u540D\uFF09",
+  builder: (yargs2) => {
+    return yargs2.positional("target", {
+      describe: "\u4E66\u7C4D ID \u6216\u4E66\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF09",
+      type: "string",
+      demandOption: true
+    });
+  },
+  handler: async (argv) => {
+    try {
+      const bookService = new BookService();
+      const book = bookService.findBook(argv.target);
+      if (!book) {
+        console.log(`\u2717 \u672A\u627E\u5230\u4E66\u7C4D: ${argv.target}`);
+        console.log("  \u4F7F\u7528 novel library \u67E5\u770B\u4E66\u67B6\u4E2D\u7684\u6240\u6709\u4E66\u7C4D\u3002");
+        process.exit(1);
+      }
+      const progressService = new ProgressService();
+      const progress = progressService.getProgress(book.id);
+      const byteOffset = progress?.byte_offset ?? 0;
+      logger.debug(`\u6253\u5F00: ${book.title}, offset=${byteOffset}`);
+      renderApp({
+        initialPage: "reader",
+        bookId: book.id,
+        initialByteOffset: byteOffset
+      });
+    } catch (error) {
+      logger.error("\u6253\u5F00\u5931\u8D25:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// src/cli/commands/library.ts
+var libraryCommand = {
+  command: "library",
+  describe: "\u67E5\u770B\u4E66\u67B6\u5217\u8868",
+  builder: (yargs2) => {
+    return yargs2.option("search", {
+      alias: "s",
+      describe: "\u641C\u7D22\u4E66\u540D",
+      type: "string"
+    });
+  },
+  handler: async (argv) => {
+    try {
+      if (argv.search) {
+        const bookService = new BookService();
+        const books = bookService.searchBooks(argv.search);
+        if (books.length === 0) {
+          console.log(`\u{1F4DA} \u672A\u627E\u5230\u5339\u914D\u300C${argv.search}\u300D\u7684\u4E66\u7C4D\u3002`);
+          return;
+        }
+        console.log(`\u{1F4DA} \u641C\u7D22\u7ED3\u679C (${books.length} \u672C):
+`);
+        books.forEach((book, index) => {
+          console.log(`  ${index + 1}. ${book.title}  [${book.id}]  (${book.format})`);
+        });
+        return;
+      }
+      renderApp({ initialPage: "library" });
+    } catch (error) {
+      logger.error("\u83B7\u53D6\u4E66\u67B6\u5931\u8D25:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// src/cli/commands/remove.ts
+var removeCommand = {
+  command: "remove <target>",
+  describe: "\u4ECE\u4E66\u67B6\u79FB\u9664\u4E66\u7C4D\uFF08\u4EC5\u5220\u9664\u8BB0\u5F55\uFF0C\u4E0D\u5220\u6E90\u6587\u4EF6\uFF09",
+  builder: (yargs2) => {
+    return yargs2.positional("target", {
+      describe: "\u4E66\u7C4D ID \u6216\u4E66\u540D\uFF08\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF09",
+      type: "string",
+      demandOption: true
+    });
+  },
+  handler: async (argv) => {
+    try {
+      const bookService = new BookService();
+      const book = bookService.findBook(argv.target);
+      if (!book) {
+        console.log(`\u2717 \u672A\u627E\u5230\u5339\u914D\u4E66\u7C4D: ${argv.target}`);
+        process.exit(1);
+      }
+      bookService.deleteBook(book.id);
+      console.log(`\u2713 \u5DF2\u79FB\u9664\u4E66\u7C4D: ${book.title}`);
+    } catch (error) {
+      logger.error("\u79FB\u9664\u4E66\u7C4D\u5931\u8D25:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// src/cli/parser.ts
+function createParser() {
+  return yargs(hideBin(process.argv)).scriptName("novel").usage("$0 <command> [options]").command(importCommand).command(resumeCommand).command(openCommand).command(libraryCommand).command(removeCommand).demandCommand(1, "\u8BF7\u6307\u5B9A\u4E00\u4E2A\u547D\u4EE4\u3002\u4F7F\u7528 --help \u67E5\u770B\u53EF\u7528\u547D\u4EE4\u3002").strict().alias("h", "help").alias("v", "version").version("0.1.0").epilogue("ReadShell \u2014 \u7EC8\u7AEF\u5185\u4F4E\u6253\u65AD\u8F7B\u9605\u8BFB\u5DE5\u5177");
+}
+
+// src/db/migrate.ts
+var SCHEMA_VERSION = 2;
+function initDatabase() {
+  const db2 = getDb();
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY
+    );
+  `);
+  const row = db2.prepare("SELECT version FROM schema_version LIMIT 1").get();
+  const currentVersion = row?.version ?? 0;
+  if (currentVersion < SCHEMA_VERSION) {
+    logger.debug(`\u6570\u636E\u5E93\u8FC1\u79FB: v${currentVersion} \u2192 v${SCHEMA_VERSION}`);
+    migrate(db2, currentVersion);
+  }
+}
+function migrate(db2, fromVersion) {
+  const migrations = {
+    1: `
+      -- \u4E66\u7C4D\u5143\u6570\u636E
+      CREATE TABLE IF NOT EXISTS books (
+        id          TEXT PRIMARY KEY,
+        title       TEXT NOT NULL,
+        author      TEXT,
+        file_path   TEXT NOT NULL,
+        format      TEXT NOT NULL,
+        file_hash   TEXT NOT NULL,
+        file_size   INTEGER,
+        created_at  INTEGER NOT NULL
+      );
+
+      -- \u6838\u5FC3\u72B6\u6001\u8868
+      CREATE TABLE IF NOT EXISTS reading_progress (
+        book_id     TEXT PRIMARY KEY REFERENCES books(id),
+        chapter_no  INTEGER NOT NULL DEFAULT 0,
+        byte_offset INTEGER NOT NULL DEFAULT 0,
+        percent     REAL NOT NULL DEFAULT 0,
+        updated_at  INTEGER NOT NULL,
+        opened_at   INTEGER NOT NULL
+      );
+
+      -- \u6700\u8FD1\u9605\u8BFB\u6392\u5E8F
+      CREATE TABLE IF NOT EXISTS recent_reads (
+        book_id     TEXT PRIMARY KEY REFERENCES books(id),
+        opened_at   INTEGER NOT NULL,
+        open_count  INTEGER NOT NULL DEFAULT 1
+      );
+
+      -- \u7AE0\u8282\u7D22\u5F15
+      CREATE TABLE IF NOT EXISTS chapter_index (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        book_id     TEXT NOT NULL REFERENCES books(id),
+        chapter_no  INTEGER NOT NULL,
+        title       TEXT,
+        byte_offset INTEGER NOT NULL,
+        UNIQUE(book_id, chapter_no)
+      );
+
+      -- \u7D22\u5F15
+      CREATE INDEX IF NOT EXISTS idx_chapter_book ON chapter_index(book_id);
+      CREATE INDEX IF NOT EXISTS idx_recent_opened ON recent_reads(opened_at DESC);
+    `,
+    2: `
+      -- \u4E66\u7B7E\u7BA1\u7406
+      CREATE TABLE IF NOT EXISTS bookmarks (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        book_id     TEXT NOT NULL REFERENCES books(id),
+        title       TEXT NOT NULL,
+        byte_offset INTEGER NOT NULL,
+        created_at  INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_bookmarks_book ON bookmarks(book_id);
+    `
+  };
+  db2.transaction(() => {
+    for (let v = fromVersion + 1; v <= SCHEMA_VERSION; v++) {
+      const sql = migrations[v];
+      if (sql) {
+        db2.exec(sql);
+        logger.debug(`\u5DF2\u6267\u884C\u8FC1\u79FB v${v}`);
+      }
+    }
+    db2.prepare("DELETE FROM schema_version").run();
+    db2.prepare("INSERT INTO schema_version (version) VALUES (?)").run(SCHEMA_VERSION);
+  })();
+}
+
+// src/index.ts
+async function main() {
+  try {
+    initDatabase();
+    const parser = createParser();
+    await parser.parse();
+  } catch (error) {
+    logger.error("\u7A0B\u5E8F\u542F\u52A8\u5931\u8D25:", error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map