moyu-ghost 1.0.0

package/README.md

@@ -0,0 +1,169 @@
+# VS-Ghost 使用文档
+
+`vs-ghost` 是一个运行在 VS Code 终端中的隐蔽阅读器。  
+它会把小说内容伪装成前端构建日志输出，适合在终端环境中阅读 `.txt` / `.epub` 书籍。
+
+## 1. 功能概览
+
+- 伪装输出：正文以构建日志形式输出，穿插噪声日志。
+- 自动翻页为主：支持按阅读速度自动滚动。
+- 手动调位：保留上下方向键快速调整当前位置。
+- 目录解析与跳转：`.epub` 解析真实目录（nav/NCX），`.txt` 按章节标题规则生成伪目录。
+- 老板键：`Ctrl + C` 触发伪构建崩溃并快速刷屏退出。
+- 进度记忆：自动保存阅读位置与速度，下次继续。
+
+## 2. 环境要求
+
+- Node.js 18+（推荐 LTS，已在 Node 24 环境验证）
+- Windows / macOS / Linux 终端均可（推荐 VS Code Integrated Terminal）
+
+## 3. 安装与启动
+
+1. 安装依赖：
+
+```bash
+npm install
+```
+
+2. 初始化数据目录（建议先执行）：
+
+```bash
+npm run init
+```
+
+3. 放入小说文件到 `logs_data` 目录（支持 `.txt` / `.epub`）。
+默认目录：
+- Windows：`C:\Users\<用户名>\.vs-ghost\logs_data`
+- macOS/Linux：`~/.vs-ghost/logs_data`
+
+可选：你也可以设置环境变量 `VS_GHOST_HOME` 自定义根目录，程序会使用 `<VS_GHOST_HOME>/logs_data`。
+
+4. 启动：
+
+```bash
+npm start
+```
+
+5. 启动后输入书籍序号，回车确认。
+
+## 4. 键位说明
+
+| 按键 | 功能 | 说明 |
+| --- | --- | --- |
+| `a` | 自动翻页开关 | 主阅读模式，开/关自动滚动 |
+| `Down Arrow` | 下一行 | 手动向前调位 |
+| `Up Arrow` | 上一行 | 手动回退调位（会输出重处理警告） |
+| `[` / `-` / `Left Arrow` | 降速 | 自动翻页速度降低 |
+| `]` / `=` / `Right Arrow` | 加速 | 自动翻页速度提高 |
+| `t` | 打开目录 | 打印目录并进入跳转输入模式 |
+| `Ctrl + C` | 老板键 | 触发伪构建错误 + 50 行堆栈后退出 |
+| `Esc` | 正常退出 | 直接退出程序（不触发伪崩溃） |
+
+## 5. 自动翻页规则
+
+- 速度单位：`han-chars/s`（每秒汉字数）。
+- 默认速度：`10 han-chars/s`。
+- 可调范围：`4 ~ 60 han-chars/s`。
+- 计速只统计汉字，不统计空格、英文标点和符号。
+- 最小翻页间隔：`500ms`（防止短句滚动过快）。
+- 最大翻页间隔：`7000ms`（防止长句停留过久）。
+
+## 6. 目录（TOC）跳转
+
+按 `t` 后会打印目录，并提示输入跳转参数。
+
+支持两种输入方式：
+
+- 输入章节号（推荐）：例如 `105`
+- 输入目录序号：例如 `#105` 或 `i105`
+
+优先级规则：
+
+- 纯数字优先按“章节号”匹配。
+- 若没有匹配章节号，再按“目录序号”匹配。
+
+示例：
+
+- 输入 `105` -> 优先跳转到 `第105章 ...`
+- 输入 `#105` -> 强制跳到 TOC 第 105 项
+
+## 7. 进度与配置保存
+
+程序会在数据目录根路径写入 `.ghost-session.json`（默认在 `~/.vs-ghost/.ghost-session.json`），按书籍保存：
+
+- `index`：当前阅读位置
+- `autoCharsPerSecond`：自动翻页速度
+- `updatedAt`：更新时间
+
+重启后会自动续读。  
+如果你想恢复默认速度，可删除对应书籍会话项或删除整个 `.ghost-session.json`。
+
+## 8. 目录结构
+
+```text
+.
+├─ index.js           # 主程序入口（交互、状态、自动翻页、TOC 跳转）
+├─ parser.js          # 文本/EPUB 解析与 TOC 生成
+├─ logger.js          # 伪装日志输出
+└─ 需求文档.md         # 产品需求文档
+```
+
+运行时数据目录（默认）：
+
+```text
+~/.vs-ghost/
+├─ logs_data/          # 书籍目录（.txt/.epub）
+└─ .ghost-session.json # 进度与速度持久化
+```
+
+## 9. 常见问题
+
+1. 为什么我改了默认速度，启动后还是旧速度？
+- 因为会话文件保存了历史速度。删除 `~/.vs-ghost/.ghost-session.json`（或你自定义 `VS_GHOST_HOME` 下对应文件）即可。
+
+2. 为什么 `105` 有时不是 TOC 第 105 项？
+- 设计如此：纯数字优先当作“章节号”。要强制按 TOC 序号，请用 `#105`。
+
+3. 为什么有些 TXT 没有目录？
+- TXT 目录是规则识别（如 `第xx章`、`Chapter x`）。如果原文无明显标题，目录可能较少或为空。
+
+## 10. 打包与跨电脑使用
+
+### A. 本机打包
+
+在项目根目录执行：
+
+```bash
+npm pack
+```
+
+会生成一个压缩包，例如：`vs-ghost-1.0.0.tgz`。
+
+### B. 在另一台电脑安装
+
+把 `.tgz` 文件拷贝到目标电脑后执行：
+
+```bash
+npm install -g ./vs-ghost-1.0.0.tgz
+```
+
+安装后可用命令：
+
+- `vs-ghost-init`：创建数据目录并打印实际路径
+- `vs-ghost`：启动阅读器
+
+### C. 推荐使用流程（另一台电脑）
+
+1. `vs-ghost-init`
+2. 把小说放到命令输出的 `data path`
+3. `vs-ghost`
+
+### D. 可选：自定义数据目录
+
+设置环境变量 `VS_GHOST_HOME` 后，`vs-ghost` 与 `vs-ghost-init` 都会使用该目录：
+
+PowerShell:
+
+```powershell
+$env:VS_GHOST_HOME = "D:\\my-vs-ghost"
+```

package/index.js

@@ -0,0 +1,564 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import readline from 'node:readline/promises';
+import chalk from 'chalk';
+import keypress from 'keypress';
+import ora from 'ora';
+import { GhostLogger } from './logger.js';
+import { parseArchive, scanArchives } from './parser.js';
+
+const APP_HOME = resolveAppHome();
+const LOGS_DIR = path.join(APP_HOME, 'logs_data');
+const SESSION_FILE = path.join(APP_HOME, '.ghost-session.json');
+
+const AUTO_MIN_CHARS_PER_SEC = 4;
+const AUTO_MAX_CHARS_PER_SEC = 60;
+const AUTO_STEP_CHARS_PER_SEC = 2;
+const AUTO_DEFAULT_CHARS_PER_SEC = 10;
+
+const AUTO_MIN_DELAY_MS = 500;
+const AUTO_MAX_DELAY_MS = 7000;
+const AUTO_END_PAUSE_MS = 220;
+
+const LEGACY_BASE_LINE_CHARS = 14;
+
+const appState = {
+  archive: null,
+  lines: [],
+  toc: [],
+  nextIndex: 0,
+  autoCharsPerSecond: AUTO_DEFAULT_CHARS_PER_SEC,
+  autoPagingEnabled: false,
+  autoTimer: null,
+  autoTickQueued: false,
+  logger: null,
+  crashing: false,
+  prompting: false,
+  actionChain: Promise.resolve()
+};
+
+process.on('SIGINT', () => {
+  void triggerBossKey();
+});
+
+main().catch((error) => {
+  console.error(chalk.red(`[fatal] ${error.message}`));
+  process.exit(1);
+});
+
+async function main() {
+  const archive = await selectArchive();
+  appState.archive = archive;
+
+  const loading = ora(`parsing ${archive.name} ...`).start();
+  let parsed;
+  try {
+    parsed = await parseArchive(archive.filePath);
+    loading.succeed(`archive ready: ${archive.name}`);
+  } catch (error) {
+    loading.fail(`failed to parse ${archive.name}`);
+    throw error;
+  }
+
+  if (!parsed.lines.length) {
+    throw new Error('Archive has no readable lines.');
+  }
+
+  appState.lines = parsed.lines;
+  appState.toc = parsed.toc;
+
+  const resumeState = await loadResumeState(archive.filePath, parsed.lines.length);
+  appState.nextIndex = resumeState.index;
+  appState.autoCharsPerSecond = resumeState.autoCharsPerSecond;
+
+  appState.logger = new GhostLogger({
+    archiveName: archive.name,
+    totalLines: parsed.lines.length
+  });
+  appState.logger.printStartup(
+    appState.nextIndex,
+    appState.autoCharsPerSecond,
+    appState.toc.length
+  );
+  appState.logger.printNoise(2);
+
+  setupKeyboard();
+}
+
+async function selectArchive() {
+  const spinner = ora(`scanning ${LOGS_DIR} ...`).start();
+  const archives = await scanArchives(LOGS_DIR);
+  spinner.stop();
+
+  if (!archives.length) {
+    console.log(chalk.yellow(`[ghost] no .txt/.epub files found in ${LOGS_DIR}`));
+    console.log(chalk.gray(`[ghost] put source files into ${LOGS_DIR} and rerun npm start`));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue('[webpack-cli] discovered log archives:'));
+  for (let i = 0; i < archives.length; i += 1) {
+    const archive = archives[i];
+    console.log(
+      chalk.gray(
+        `  ${i + 1}. ${archive.name} (${archive.extension.slice(1).toUpperCase()}, ${humanSize(archive.size)})`
+      )
+    );
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    while (true) {
+      const answer = await rl.question('Select archive #: ');
+      const index = Number(answer.trim()) - 1;
+      if (Number.isInteger(index) && index >= 0 && index < archives.length) {
+        return archives[index];
+      }
+      console.log(chalk.yellow('[WARN] invalid selection, try again.'));
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function setupKeyboard() {
+  keypress(process.stdin);
+  process.stdin.on('keypress', (ch, key) => {
+    if (key?.name === 'escape') {
+      void exitNormally();
+      return;
+    }
+    if (key?.ctrl && key?.name === 'c') {
+      void triggerBossKey();
+      return;
+    }
+    if (appState.crashing || appState.prompting) {
+      return;
+    }
+
+    if (key?.name === 'down') {
+      enqueueAction(stepNext);
+      return;
+    }
+    if (key?.name === 'up') {
+      enqueueAction(stepPrevious);
+      return;
+    }
+    if (ch === 'a') {
+      enqueueAction(toggleAutoPaging);
+      return;
+    }
+    if (isSlowerKey(ch, key)) {
+      enqueueAction(() => updateAutoSpeed(-AUTO_STEP_CHARS_PER_SEC));
+      return;
+    }
+    if (isFasterKey(ch, key)) {
+      enqueueAction(() => updateAutoSpeed(+AUTO_STEP_CHARS_PER_SEC));
+      return;
+    }
+    if (ch === 't') {
+      enqueueAction(openTocMenu);
+    }
+  });
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+}
+
+function enqueueAction(action) {
+  appState.actionChain = appState.actionChain
+    .then(() => action())
+    .catch((error) => {
+      console.error(chalk.red(`[runtime] ${error.message}`));
+    });
+}
+
+async function stepNext() {
+  if (appState.nextIndex >= appState.lines.length) {
+    appState.logger.printEnd();
+    if (appState.autoPagingEnabled) {
+      stopAutoPaging('eof');
+    }
+    return false;
+  }
+
+  const line = appState.lines[appState.nextIndex];
+  appState.logger.printFrame(line, appState.nextIndex + 1);
+  appState.nextIndex += 1;
+  await saveProgress();
+  return true;
+}
+
+async function stepPrevious() {
+  appState.logger.printRetry();
+  if (appState.nextIndex === 0) {
+    appState.logger.printNoise(2);
+    return;
+  }
+
+  const targetIndex = Math.max(0, appState.nextIndex - 2);
+  appState.nextIndex = targetIndex;
+  await stepNext();
+}
+
+async function openTocMenu() {
+  if (!appState.toc.length) {
+    appState.logger.printTocEmpty();
+    return;
+  }
+
+  appState.logger.printTocHeader(appState.toc.length);
+  for (let i = 0; i < appState.toc.length; i += 1) {
+    const item = appState.toc[i];
+    appState.logger.printTocEntry(i + 1, item.title, item.lineIndex + 1);
+  }
+  appState.logger.printTocPrompt();
+
+  const answer = await promptLine('TOC jump (chapter or #index): ');
+  if (!answer) {
+    appState.logger.printTocCanceled();
+    return;
+  }
+
+  const selection = resolveTocSelection(answer, appState.toc);
+  if (!selection) {
+    appState.logger.printTocInvalid(answer);
+    appState.logger.printNoise(2);
+    return;
+  }
+
+  const selected = selection.item;
+  appState.nextIndex = clampNumber(selected.lineIndex, 0, appState.lines.length - 1);
+  await saveProgress();
+  appState.logger.printTocJump(
+    selected.title,
+    appState.nextIndex + 1,
+    selection.mode
+  );
+
+  if (appState.autoPagingEnabled && !appState.autoTickQueued) {
+    scheduleNextAutoTick(0);
+  }
+}
+
+function resolveTocSelection(input, toc) {
+  const trimmed = String(input ?? '').trim();
+  const indexOnly = trimmed.startsWith('#')
+    ? Number(trimmed.slice(1))
+    : /^i\d+$/i.test(trimmed)
+      ? Number(trimmed.slice(1))
+      : null;
+
+  if (Number.isInteger(indexOnly) && indexOnly > 0) {
+    const byIndexOnly = indexOnly - 1;
+    if (byIndexOnly >= 0 && byIndexOnly < toc.length) {
+      return { item: toc[byIndexOnly], mode: 'index' };
+    }
+    return null;
+  }
+
+  const numeric = Number(trimmed);
+  if (!Number.isInteger(numeric) || numeric <= 0) {
+    return null;
+  }
+
+  // Priority: chapter number -> toc index.
+  const byChapter = toc.find((item) => extractChapterNumber(item.title) === numeric);
+  if (byChapter) {
+    return { item: byChapter, mode: 'chapter' };
+  }
+
+  const index = numeric - 1;
+  if (index >= 0 && index < toc.length) {
+    return { item: toc[index], mode: 'index' };
+  }
+  return null;
+}
+
+async function promptLine(text) {
+  appState.prompting = true;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    return (await rl.question(chalk.cyan(text))).trim();
+  } finally {
+    rl.close();
+    appState.prompting = false;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+  }
+}
+
+async function loadResumeState(filePath, totalLines) {
+  const session = await loadSession();
+  const key = archiveKey(filePath);
+  const savedIndex = Number(session?.[key]?.index);
+  const savedSpeed = Number(session?.[key]?.autoCharsPerSecond);
+  const legacyIntervalMs = Number(session?.[key]?.autoIntervalMs);
+  const resolvedSpeed = Number.isFinite(savedSpeed)
+    ? savedSpeed
+    : legacyIntervalToCharsPerSecond(legacyIntervalMs);
+
+  return {
+    index: Number.isInteger(savedIndex) && savedIndex >= 0 && savedIndex < totalLines ? savedIndex : 0,
+    autoCharsPerSecond: clampNumber(
+      resolvedSpeed,
+      AUTO_MIN_CHARS_PER_SEC,
+      AUTO_MAX_CHARS_PER_SEC
+    )
+  };
+}
+
+async function saveProgress() {
+  if (!appState.archive) {
+    return;
+  }
+
+  await fs.mkdir(APP_HOME, { recursive: true });
+  const session = await loadSession();
+  const key = archiveKey(appState.archive.filePath);
+  session[key] = {
+    index: appState.nextIndex,
+    autoCharsPerSecond: appState.autoCharsPerSecond,
+    updatedAt: new Date().toISOString()
+  };
+  await fs.writeFile(SESSION_FILE, `${JSON.stringify(session, null, 2)}\n`, 'utf8');
+}
+
+async function loadSession() {
+  try {
+    const raw = await fs.readFile(SESSION_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {};
+    }
+    return {};
+  }
+}
+
+async function triggerBossKey() {
+  if (appState.crashing) {
+    return;
+  }
+  appState.crashing = true;
+  stopAutoPaging('panic');
+
+  try {
+    await saveProgress();
+  } catch {
+    // Ignore progress persistence errors in emergency exit.
+  }
+
+  if (!appState.logger) {
+    appState.logger = new GhostLogger({
+      archiveName: 'bootstrap',
+      totalLines: 1
+    });
+  }
+  appState.logger.printBossCrash();
+  process.exit(1);
+}
+
+async function exitNormally() {
+  if (appState.crashing) {
+    return;
+  }
+  if (appState.autoTimer) {
+    clearTimeout(appState.autoTimer);
+    appState.autoTimer = null;
+  }
+  appState.autoPagingEnabled = false;
+  appState.autoTickQueued = false;
+  try {
+    await saveProgress();
+  } catch {
+    // Ignore persistence errors on normal exit.
+  }
+  process.exit(0);
+}
+
+function toggleAutoPaging() {
+  if (appState.autoPagingEnabled) {
+    stopAutoPaging('manual');
+    return;
+  }
+  appState.autoPagingEnabled = true;
+  appState.autoTickQueued = false;
+  scheduleNextAutoTick(0);
+  appState.logger.printAutoState(true, appState.autoCharsPerSecond);
+}
+
+function stopAutoPaging(reason = '') {
+  if (!appState.autoPagingEnabled && !appState.autoTimer) {
+    return;
+  }
+  appState.autoPagingEnabled = false;
+  appState.autoTickQueued = false;
+  if (appState.autoTimer) {
+    clearTimeout(appState.autoTimer);
+    appState.autoTimer = null;
+  }
+  if (appState.logger) {
+    appState.logger.printAutoState(false, appState.autoCharsPerSecond, reason);
+  }
+}
+
+async function updateAutoSpeed(deltaCharsPerSecond) {
+  const nextSpeed = clampNumber(
+    appState.autoCharsPerSecond + deltaCharsPerSecond,
+    AUTO_MIN_CHARS_PER_SEC,
+    AUTO_MAX_CHARS_PER_SEC
+  );
+  appState.autoCharsPerSecond = nextSpeed;
+  appState.logger.printAutoSpeed(nextSpeed);
+  await saveProgress();
+
+  if (appState.autoPagingEnabled && !appState.autoTickQueued) {
+    scheduleNextAutoTick(0);
+  }
+}
+
+function scheduleNextAutoTick(delayMs) {
+  if (!appState.autoPagingEnabled) {
+    return;
+  }
+
+  if (appState.autoTimer) {
+    clearTimeout(appState.autoTimer);
+  }
+  appState.autoTimer = setTimeout(() => {
+    if (appState.crashing || !appState.autoPagingEnabled) {
+      return;
+    }
+    if (appState.prompting || appState.autoTickQueued) {
+      scheduleNextAutoTick(AUTO_MIN_DELAY_MS);
+      return;
+    }
+
+    const pendingLine = appState.lines[appState.nextIndex] ?? '';
+    const delayForNextLine = calculateAutoDelayMs(
+      pendingLine,
+      appState.autoCharsPerSecond
+    );
+
+    appState.autoTickQueued = true;
+    enqueueAction(async () => {
+      try {
+        const moved = await stepNext();
+        if (moved && appState.autoPagingEnabled) {
+          scheduleNextAutoTick(delayForNextLine);
+        }
+      } finally {
+        appState.autoTickQueued = false;
+      }
+    });
+  }, Math.max(0, delayMs));
+
+  if (typeof appState.autoTimer.unref === 'function') {
+    appState.autoTimer.unref();
+  }
+}
+
+function calculateAutoDelayMs(line, charsPerSecond) {
+  const chars = countReadableChars(line);
+  const rawDelay = (chars / charsPerSecond) * 1000;
+  const punctuationPause = /[。！？.!?；;]$/.test(String(line).trim())
+    ? AUTO_END_PAUSE_MS
+    : 0;
+
+  return clampNumber(
+    Math.round(rawDelay + punctuationPause),
+    AUTO_MIN_DELAY_MS,
+    AUTO_MAX_DELAY_MS
+  );
+}
+
+function countReadableChars(line) {
+  const hanCount = Array.from(String(line ?? ''))
+    .filter((char) => isHanCharacter(char))
+    .length;
+  return Math.max(1, hanCount);
+}
+
+function legacyIntervalToCharsPerSecond(intervalMs) {
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    return AUTO_DEFAULT_CHARS_PER_SEC;
+  }
+  return clampNumber(
+    (LEGACY_BASE_LINE_CHARS * 1000) / intervalMs,
+    AUTO_MIN_CHARS_PER_SEC,
+    AUTO_MAX_CHARS_PER_SEC
+  );
+}
+
+function archiveKey(filePath) {
+  return path.relative(LOGS_DIR, filePath).replace(/\\/g, '/');
+}
+
+function humanSize(size) {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let current = size;
+  let unit = 0;
+  while (current >= 1024 && unit < units.length - 1) {
+    current /= 1024;
+    unit += 1;
+  }
+  return `${current.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, Math.round(value)));
+}
+
+function isSlowerKey(ch, key) {
+  return ch === '[' || ch === '-' || ch === '_' || key?.name === 'left';
+}
+
+function isFasterKey(ch, key) {
+  return ch === ']' || ch === '=' || ch === '+' || key?.name === 'right';
+}
+
+function isHanCharacter(char) {
+  return /[\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF]/.test(char);
+}
+
+function extractChapterNumber(title) {
+  const text = String(title ?? '').trim();
+  const zh = text.match(/^第\s*(\d+)\s*[章回节卷]/);
+  if (zh) {
+    return Number(zh[1]);
+  }
+  const en = text.match(/^(?:chapter|chap\.?)\s*(\d+)/i);
+  if (en) {
+    return Number(en[1]);
+  }
+  return null;
+}
+
+function resolveAppHome() {
+  const fromEnv = process.env.VS_GHOST_HOME?.trim();
+  if (fromEnv) {
+    return path.resolve(fromEnv);
+  }
+  return path.join(os.homedir(), '.vs-ghost');
+}

package/logger.js

@@ -0,0 +1,184 @@
+import chalk from 'chalk';
+
+const NOISE_TEMPLATES = [
+  () => `[webpack-cli] cache invalidated for chunk-${randomInt(7, 42)} (${randomHash(6)})`,
+  () => `[HMR] heartbeat sync completed in ${randomInt(8, 44)}ms`,
+  () => `[vite] pre-bundling dependency graph node ${randomInt(110, 980)}`,
+  () => `[ESLint] checked ${randomInt(4, 25)} files, ${randomInt(0, 2)} warnings`,
+  () => `Asset optimization: dist/runtime-${randomHash(8)}.js (${randomInt(22, 96)}.1 kB)`,
+  () => `[Parser] scanned src/modules/memo-${randomHash(5)}.tsx`,
+  () => `[ts-loader] transpiled ${randomInt(2, 12)} modules with incremental cache`,
+  () => `[build] tree-shaking ${randomInt(2, 11)} dead exports from vendor chunk`,
+  () => `[rollup] emitted sourcemap for app-shell-${randomHash(4)}.css`
+];
+
+const CONTENT_TEMPLATES = [
+  (line, index, total) =>
+    `[INFO] [Parser] Analyzed dependency #${index}/${total}: "${line}"`,
+  (line) =>
+    `[INFO] [AssetGraph] Parsed virtual module -> "${line}"`,
+  (line) =>
+    `[INFO] [Loader] Linked text payload from chunk: "${line}"`,
+  (line) =>
+    `[INFO] [Resolver] Confirmed import trace: "${line}"`
+];
+
+const STACK_TEMPLATES = [
+  () =>
+    `    at Object.compile (node_modules/webpack/lib/Compiler.js:${randomInt(80, 490)}:${randomInt(3, 98)})`,
+  () =>
+    `    at runBuildPipeline (node_modules/vite/dist/node/chunks/dep-${randomHash(8)}.js:${randomInt(40, 910)}:${randomInt(3, 98)})`,
+  () =>
+    `    at async transformWithEsbuild (node_modules/esbuild/lib/main.js:${randomInt(200, 1200)}:${randomInt(3, 98)})`,
+  () =>
+    `    at processTicksAndRejections (node:internal/process/task_queues:${randomInt(40, 95)}:${randomInt(3, 20)})`,
+  () =>
+    `    at ModuleLoader.resolve (node_modules/webpack/lib/NormalModule.js:${randomInt(50, 700)}:${randomInt(3, 98)})`
+];
+
+export class GhostLogger {
+  constructor({ archiveName, totalLines }) {
+    this.archiveName = archiveName;
+    this.totalLines = totalLines;
+    this.buildToken = randomHash(6);
+  }
+
+  printStartup(resumeIndex, charsPerSecond, tocCount) {
+    console.log(chalk.blue(`[webpack-cli] build mode=production token=${this.buildToken}`));
+    console.log(chalk.gray(`[ghost] attached archive: ${this.archiveName}`));
+    console.log(chalk.dim(`[ghost] source lines: ${this.totalLines}, resume at ${resumeIndex + 1}`));
+    console.log(chalk.dim(`[ghost] auto speed: ${charsPerSecond} han-chars/s, toc: ${tocCount} entries`));
+    console.log(
+      chalk.gray(
+        '[ghost] keys: down next | up prev | a auto | [/left/- slower | ]/right/= faster | t toc | ctrl+c boss | esc exit'
+      )
+    );
+  }
+
+  printFrame(line, index) {
+    const content = choose(CONTENT_TEMPLATES)(compactLine(line), index, this.totalLines);
+    console.log(chalk.green(content));
+    this.printNoise(randomInt(2, 3));
+  }
+
+  printRetry() {
+    console.log(chalk.yellow('[WARN] Re-processing chunk...'));
+  }
+
+  printAutoState(enabled, charsPerSecond, reason = '') {
+    const suffix = reason ? ` (${reason})` : '';
+    if (enabled) {
+      console.log(
+        chalk.white(
+          `[INFO] [Scheduler] Auto-paging enabled: speed=${charsPerSecond} han-chars/s${suffix}`
+        )
+      );
+      return;
+    }
+    console.log(
+      chalk.yellow(
+        `[WARN] [Scheduler] Auto-paging disabled${suffix}`
+      )
+    );
+  }
+
+  printAutoSpeed(charsPerSecond) {
+    console.log(
+      chalk.white(`[INFO] [Scheduler] Auto-paging speed updated -> ${charsPerSecond} han-chars/s`)
+    );
+  }
+
+  printTocHeader(total) {
+    console.log(chalk.blue(`[webpack-cli] parsed table of contents (${total} entries)`));
+  }
+
+  printTocEntry(index, title, lineNumber) {
+    console.log(
+      chalk.white(
+        `[INFO] [TOC] #${index} @line ${lineNumber}: ${compactLine(title)}`
+      )
+    );
+  }
+
+  printTocPrompt() {
+    console.log(chalk.blue('[webpack-cli] toc jump mode, input chapter number (or #toc-index) and press enter'));
+  }
+
+  printTocEmpty() {
+    console.log(chalk.yellow('[WARN] [TOC] no chapters detected in current archive'));
+    this.printNoise(2);
+  }
+
+  printTocInvalid(input) {
+    console.log(chalk.yellow(`[WARN] [TOC] invalid index "${input}"`));
+  }
+
+  printTocJump(title, lineNumber, mode = 'index') {
+    const label = mode === 'chapter' ? 'chapter' : 'index';
+    console.log(
+      chalk.white(`[INFO] [TOC] jumped by ${label} to line ${lineNumber}: ${compactLine(title)}`)
+    );
+  }
+
+  printTocCanceled() {
+    console.log(chalk.gray('[webpack-cli] toc jump canceled'));
+  }
+
+  printEnd() {
+    console.log(chalk.blue('[webpack-cli] reached end of source map stream'));
+    this.printNoise(2);
+  }
+
+  printBossCrash() {
+    console.log(
+      chalk.redBright(
+        'ERROR in ./src/main.ts Module build failed (from ./node_modules/ts-loader):'
+      )
+    );
+    for (let i = 0; i < 50; i += 1) {
+      console.log(chalk.red(choose(STACK_TEMPLATES)()));
+    }
+  }
+
+  printNoise(count) {
+    for (let i = 0; i < count; i += 1) {
+      console.log(colorNoise(choose(NOISE_TEMPLATES)()));
+    }
+  }
+}
+
+function colorNoise(line) {
+  const pick = randomInt(0, 2);
+  if (pick === 0) {
+    return chalk.dim(line);
+  }
+  if (pick === 1) {
+    return chalk.gray(line);
+  }
+  return chalk.blue(line);
+}
+
+function compactLine(line) {
+  const trimmed = String(line).replace(/\s+/g, ' ').trim();
+  if (trimmed.length <= 110) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, 107)}...`;
+}
+
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function randomHash(length) {
+  const alphabet = 'abcdef0123456789';
+  let out = '';
+  for (let i = 0; i < length; i += 1) {
+    out += alphabet[Math.floor(Math.random() * alphabet.length)];
+  }
+  return out;
+}
+
+function choose(array) {
+  return array[Math.floor(Math.random() * array.length)];
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "moyu-ghost",
+  "version": "1.0.0",
+  "description": "Stealth CLI reader disguised as frontend build logs.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "moyu-ghost": "index.js",
+    "moyu-ghost-init": "scripts/init.js",
+    "vs-ghost": "index.js",
+    "vs-ghost-init": "scripts/init.js"
+  },
+  "files": [
+    "index.js",
+    "logger.js",
+    "parser.js",
+    "scripts/init.js",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node index.js",
+    "init": "node scripts/init.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "epub-parser": "^0.2.5",
+    "keypress": "^0.2.1",
+    "node-html-parser": "^6.1.13",
+    "ora": "^8.1.1"
+  }
+}

package/parser.js

@@ -0,0 +1,355 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { parse as parseHtml } from 'node-html-parser';
+
+const require = createRequire(import.meta.url);
+const epubParser = require('epub-parser');
+
+const SUPPORTED_EXTENSIONS = new Set(['.txt', '.epub']);
+const MAX_TOC_ENTRIES = 5000;
+
+export async function scanArchives(logsDir) {
+  await fs.mkdir(logsDir, { recursive: true });
+  const entries = await fs.readdir(logsDir, { withFileTypes: true });
+
+  const archives = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const extension = path.extname(entry.name).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(extension)) {
+      continue;
+    }
+    const filePath = path.join(logsDir, entry.name);
+    const stat = await fs.stat(filePath);
+    archives.push({
+      name: entry.name,
+      extension,
+      filePath,
+      size: stat.size
+    });
+  }
+
+  archives.sort((a, b) => a.name.localeCompare(b.name, 'zh-Hans-CN'));
+  return archives;
+}
+
+export async function parseArchive(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === '.txt') {
+    return readTxt(filePath);
+  }
+  if (extension === '.epub') {
+    return readEpub(filePath);
+  }
+  throw new Error(`Unsupported archive format: ${extension}`);
+}
+
+async function readTxt(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const lines = splitLines(content);
+  return {
+    lines,
+    toc: buildTxtToc(lines)
+  };
+}
+
+async function readEpub(filePath) {
+  const epubData = await openEpub(filePath);
+  const zip = epubParser.getZip();
+  const context = {
+    itemHashByHref: epubData?.easy?.itemHashByHref ?? {},
+    opsRoot: epubData?.paths?.opsRoot ?? ''
+  };
+  const sections = extractSpineTargets(epubData, context);
+
+  const lines = [];
+  const sectionLineStartMap = new Map();
+  for (const itemPath of sections) {
+    if (!sectionLineStartMap.has(itemPath)) {
+      sectionLineStartMap.set(itemPath, lines.length);
+    }
+    const file = zip.file(itemPath);
+    if (!file) {
+      continue;
+    }
+    const html = file.asText();
+    const text = stripHtml(html);
+    lines.push(...splitLines(text));
+  }
+
+  let outputLines = lines;
+  if (lines.length > 0) {
+    const toc = buildEpubToc(epubData, context, sectionLineStartMap, lines.length);
+    return {
+      lines,
+      toc: toc.length > 0 ? toc : buildTxtToc(lines)
+    };
+  }
+
+  const fallbackStrings = [];
+  collectStrings(epubData, fallbackStrings);
+  outputLines = fallbackStrings
+    .map((value) => stripHtml(value))
+    .flatMap((value) => splitLines(value))
+    .filter((line) => line.length >= 2);
+
+  return {
+    lines: uniqueLines(outputLines),
+    toc: buildTxtToc(outputLines)
+  };
+}
+
+function openEpub(filePath) {
+  return new Promise((resolve, reject) => {
+    epubParser.open(filePath, (error, epubData) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(epubData);
+    });
+  });
+}
+
+function extractSpineTargets(epubData, context) {
+  const easy = epubData?.easy ?? {};
+  const linearSpine = easy.linearSpine ?? {};
+  const seen = new Set();
+  const targets = [];
+  for (const value of Object.values(linearSpine)) {
+    const href = value?.item?.$?.href;
+    if (!href) {
+      continue;
+    }
+    const normalized = resolveSpinePath(context, href);
+    if (normalized && !seen.has(normalized)) {
+      seen.add(normalized);
+      targets.push(normalized);
+    }
+  }
+  return targets;
+}
+
+function resolveSpinePath(context, href) {
+  const cleanedHref = normalizePathKey(href);
+  if (!cleanedHref) {
+    return '';
+  }
+
+  if (context.itemHashByHref[cleanedHref]) {
+    return cleanedHref;
+  }
+
+  const candidate = normalizePathKey(`${context.opsRoot}${cleanedHref}`);
+  if (context.itemHashByHref[candidate]) {
+    return candidate;
+  }
+
+  return candidate;
+}
+
+function buildEpubToc(epubData, context, sectionLineStartMap, totalLines) {
+  const entries = parseEpubNavEntries(epubData);
+  if (entries.length === 0) {
+    return [];
+  }
+
+  const resolved = [];
+  const seen = new Set();
+  for (const entry of entries) {
+    const lineIndex = resolveTocLineIndex(entry.href, context, sectionLineStartMap);
+    if (lineIndex < 0 || lineIndex >= totalLines) {
+      continue;
+    }
+    const title = compactTitle(entry.title);
+    if (!title) {
+      continue;
+    }
+    const signature = `${title}@@${lineIndex}`;
+    if (seen.has(signature)) {
+      continue;
+    }
+    seen.add(signature);
+    resolved.push({
+      title,
+      lineIndex
+    });
+    if (resolved.length >= MAX_TOC_ENTRIES) {
+      break;
+    }
+  }
+  return resolved;
+}
+
+function parseEpubNavEntries(epubData) {
+  const rawHtmlCandidates = [
+    epubData?.easy?.navMapHTML,
+    epubData?.easy?.epub3NavHtml
+  ].filter((value) => typeof value === 'string' && value.trim().length > 0);
+
+  for (const html of rawHtmlCandidates) {
+    const anchors = parseAnchorsFromHtml(html);
+    if (anchors.length > 0) {
+      return anchors;
+    }
+  }
+  return [];
+}
+
+function parseAnchorsFromHtml(html) {
+  try {
+    const root = parseHtml(html);
+    const nodes = root.querySelectorAll('a');
+    return nodes
+      .map((node) => ({
+        href: normalizePathKey(node.getAttribute('href') ?? ''),
+        title: compactTitle(node.text)
+      }))
+      .filter((entry) => entry.href.length > 0 && entry.title.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+function resolveTocLineIndex(href, context, sectionLineStartMap) {
+  const normalizedHref = normalizePathKey(href);
+  if (!normalizedHref) {
+    return -1;
+  }
+
+  const resolved = resolveSpinePath(context, normalizedHref);
+  if (sectionLineStartMap.has(resolved)) {
+    return sectionLineStartMap.get(resolved);
+  }
+
+  const targetBasename = path.posix.basename(resolved);
+  for (const [sectionPath, index] of sectionLineStartMap.entries()) {
+    if (
+      sectionPath === targetBasename ||
+      sectionPath.endsWith(`/${targetBasename}`)
+    ) {
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+function buildTxtToc(lines) {
+  const toc = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!isLikelyTxtHeading(line)) {
+      continue;
+    }
+    const title = compactTitle(line);
+    if (!title) {
+      continue;
+    }
+    const previous = toc[toc.length - 1];
+    if (previous && previous.title === title) {
+      continue;
+    }
+    toc.push({
+      title,
+      lineIndex: i
+    });
+    if (toc.length >= MAX_TOC_ENTRIES) {
+      break;
+    }
+  }
+  return toc;
+}
+
+function isLikelyTxtHeading(line) {
+  const text = compactTitle(line);
+  if (!text || text.length > 50) {
+    return false;
+  }
+
+  const patterns = [
+    /^第[\d零一二三四五六七八九十百千万两〇壹贰叁肆伍陆柒捌玖拾佰仟]+[章回节卷部篇集]/,
+    /^卷[\d零一二三四五六七八九十百千万两〇壹贰叁肆伍陆柒捌玖拾佰仟]+/,
+    /^(序章|序|楔子|引子|前言|后记|尾声|终章|番外|附录)/,
+    /^(chapter|chap\.?)\s*\d+/i,
+    /^(prologue|epilogue)\b/i
+  ];
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function stripHtml(value) {
+  const source = String(value ?? '');
+  if (!source.includes('<')) {
+    return source.replace(/\uFEFF/g, '');
+  }
+  try {
+    return parseHtml(source).text.replace(/\uFEFF/g, '');
+  } catch {
+    return source.replace(/<[^>]+>/g, ' ').replace(/\uFEFF/g, '');
+  }
+}
+
+function splitLines(content) {
+  return String(content)
+    .split(/\r?\n/)
+    .map((line) => line.replace(/\s+/g, ' ').trim())
+    .filter((line) => line.length > 0);
+}
+
+function uniqueLines(lines) {
+  const output = [];
+  const seen = new Set();
+  for (const line of lines) {
+    if (line.length < 2) {
+      continue;
+    }
+    if (seen.has(line)) {
+      continue;
+    }
+    seen.add(line);
+    output.push(line);
+  }
+  return output;
+}
+
+function compactTitle(value) {
+  return String(value ?? '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function normalizePathKey(value) {
+  return String(value ?? '')
+    .split('#')[0]
+    .replace(/\\/g, '/')
+    .replace(/^\.\//, '')
+    .replace(/^\/+/, '')
+    .trim();
+}
+
+function collectStrings(node, out, depth = 0) {
+  if (depth > 20 || node === null || node === undefined) {
+    return;
+  }
+
+  if (typeof node === 'string') {
+    out.push(node);
+    return;
+  }
+
+  if (Array.isArray(node)) {
+    for (const value of node) {
+      collectStrings(value, out, depth + 1);
+    }
+    return;
+  }
+
+  if (typeof node === 'object') {
+    for (const value of Object.values(node)) {
+      collectStrings(value, out, depth + 1);
+    }
+  }
+}

package/scripts/init.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+
+const appHome = resolveAppHome();
+const logsDir = path.join(appHome, 'logs_data');
+const sessionFile = path.join(appHome, '.ghost-session.json');
+
+await fs.mkdir(logsDir, { recursive: true });
+
+console.log('[vs-ghost] initialization complete');
+console.log(`[vs-ghost] app home: ${appHome}`);
+console.log(`[vs-ghost] data path: ${logsDir}`);
+console.log(`[vs-ghost] session file: ${sessionFile}`);
+console.log('[vs-ghost] put your .txt/.epub files into the data path above');
+
+function resolveAppHome() {
+  const fromEnv = process.env.VS_GHOST_HOME?.trim();
+  if (fromEnv) {
+    return path.resolve(fromEnv);
+  }
+  return path.join(os.homedir(), '.vs-ghost');
+}