dsh-novel-writer 0.2.0 → 0.4.0

package/README.md

@@ -1,132 +1,78 @@
-# 📚 dsh-novel-writer — 小说写作助手 / Novel Writing Assistant
+# dsh-novel-writer — 小说写作助手插件
 
-**中文** | [**English**](#english)
+DSH（DeepSeek Harness）小说写作助手 bundle 插件。零第三方依赖（仅 Node 内置模块），
+为 AI 提供小说章节库管理、分析与续写辅助能力。
 
-一个零第三方依赖（仅 Node 内置模块）的 **DeepSeek Harness (DSH / Cordis) 插件**，为 AI 提供小说章节库管理、剧情分析与续写辅助的能力。
+## 功能（对应需求）
 
-A **zero-dependency** (Node built-ins only) **DeepSeek Harness (DSH / Cordis) plugin** that gives the AI novel-chapter-library management, plot analysis, and continuation-writing assistance.
-
----
-
-## 功能 / Features
-
-### 🇨🇳 中文
-
-1. **章节库管理**：章节存放于 `novels/<书名>/第N章.md`（也支持 `.txt` / `.markdown`），
-   插件提供 `novel_books` / `novel_chapters` / `novel_read` 让你（AI）浏览库、列出章节并逐章阅读。
-2. **智能章号识别**：章节文件名中的序号支持**任意位置**与多种写法，
-   例如 `第01章.md`、`01-标题.md`、`原稿件-单章-…第一章.txt`，
-   阿拉伯数字与中文数字（第一章/第十四章/第三十章）均可识别，并自动按章号排序。
-3. **编码自动探测**：UTF-8（含/不含 BOM）、UTF-16 LE/BE（含 BOM 或启发式）、GBK/GB18030（无 BOM）均可直接读取，无需手动转码（如记事本另存的 Unicode 文本）。
-4. **关键词分析**：`novel_keywords` 确定性提取全书/单章高频关键词（中文相邻二字词组 + 高频单字 + 英文词），
+1. **章节库**：章节存于 `novels/<书名>/第N章.md`（或 `.txt`/`.markdown`），
+   插件提供 `novel_books` / `novel_chapters` / `novel_read` 让 AI 浏览并读取每一章内容。
+   章节文件名中的序号支持任意位置与多种写法，例如：
+   `第01章.md`、`01-标题.md`、`原稿件-单章-…第一章.txt`、`原稿件-单章-第25章 .txt`
+   （阿拉伯数字与中文数字"第一章/第十四章/第三十章"均可识别，自动按章号排序）。
+   文件编码自动探测：UTF-8（含/不含 BOM）、UTF-16 LE/BE（含 BOM 或启发式识别）、GBK/GB18030（无 BOM），
+   无需手动转码即可读取（如记事本另存的 Unicode 文本）。
+2. **分析**：`novel_keywords` 确定性提取全书/单章高频关键词（中文相邻二字词组 + 高频单字 + 英文词），
    配合系统提示词引导 AI 分析剧情脉络、写作手法、词汇偏好与意象母题。
-5. **续写辅助**：系统提示词规定续写工作流（先读后写、保持文风与伏笔一致），
-   `novel_new_chapter` 自动创建下一章文件。
-
-### 🇬🇧 English
-
-1. **Chapter-library management**: chapters live under `novels/<book>/第N章.md` (also `.txt` / `.markdown`).
-   `novel_books` / `novel_chapters` / `novel_read` let the AI browse, list, and read chapters.
-2. **Smart chapter numbering**: chapter numbers may appear **anywhere** in the filename and in many forms,
-   e.g. `第01章.md`, `01-title.md`, `raw-…Chapter-1.txt`. Both Arabic and **Chinese numerals**
-   (第一章 / 第十四章 / 第三十章) are recognized and chapters are sorted by number automatically.
-3. **Automatic encoding detection**: UTF-8 (with/without BOM), UTF-16 LE/BE (BOM or heuristic), and
-   GBK/GB18030 (no BOM) are decoded on the fly — no manual transcoding needed.
-4. **Keyword analysis**: `novel_keywords` deterministically extracts high-frequency words from a whole book
-   or one chapter (Chinese bigrams + characters + English words), guiding the AI to analyze plot,
-   writing style, vocabulary preferences, and imagery motifs.
-5. **Continuation writing**: a system prompt enforces the workflow (read first, then write; keep style and
-   foreshadowing consistent). `novel_new_chapter` creates the next chapter file automatically.
-
----
-
-## 提供的工具 / Provided Tools
-
-| Tool | 中文说明 | English |
-|------|----------|---------|
-| `novel_books` | 列出章节库全部作品（章节数、总字数） | List all books in the library (chapter count, total chars) |
-| `novel_chapters` | 列出某作品章节清单（章号/标题/字数/行数/更新时间） | List a book's chapters (number/title/chars/lines/updated) |
-| `novel_read` | 阅读某章正文（行号 + 字数统计，offset/limit 分段） | Read a chapter's body (line numbers + char count, paginated) |
-| `novel_keywords` | 提取高频关键词（可单章或全书） | Extract high-frequency keywords (chapter or whole book) |
-| `novel_new_chapter` | 创建新章节文件（自动取下一个章号） | Create a new chapter file (auto-next number) |
-
----
-
-## 安装 / Installation
-
-> 现代安装请优先参考 `INSTALL.md`，或使用 DSH CLI：
-
-> Preferred install via DSH CLI, see also `INSTALL.md`:
+3. **续写**：系统提示词规定续写工作流（先读后写、保持文风与伏笔一致），
+   `novel_new_chapter` 创建新章节文件。
+4. **原稿件批量导入/自动分类**：`novel_import` 扫描存放多本小说稿件的文件夹
+   （支持子文件夹、UTF-16/GBK 等编码、任意位置章号），从文件名与文件头内容双通道
+   提取书名候选并聚合成分组建议（scan 模式），AI 确认后可一键按书分类复制/移动到
+   `novels/<书名>/`（apply 模式）；支持 `book` 强制归并异名同书、`files` 精确指定文件。
+
+## 提供的工具
+
+| 工具 | 说明 |
+|---|---|
+| `novel_books` | 列出章节库全部作品（章节数、总字数） |
+| `novel_chapters` | 列出某作品章节清单（章号/标题/字数/行数/更新时间） |
+| `novel_read` | 阅读某章正文（行号 + 字数统计，offset/limit 分段） |
+| `novel_keywords` | 提取高频关键词（可单章或全书） |
+| `novel_new_chapter` | 创建新章节文件（自动取下一个章号） |
+| `novel_import` | 扫描原稿件文件夹，自动识别/分类多本小说章节到 `novels/<书名>/`（scan 预览 / apply 执行，支持 book 强制归并与 files 精确导入） |
+| `novel_style_pattern` | **（受 stylePattern 开关控制）** 句式模式分析：把句子分为陈述/环境/心理/对话/疑问/反问/感叹七类，输出占比、高频组合与按章节的压缩排列序列，用于模仿原文叙事节奏 |
+
+## 安装（web profile）
 
 ```sh
-dsh plugin --profile web add D:/path/to/dsh-novel-writer
-```
-
-或手动等价操作：在 profile 的 `package.json` 的 `dsh.profile.bundles` 中加入 `dsh-novel-writer`，
-并在 profile `node_modules` 中链接本包（Windows 可建 junction：`mklink /J`）。安装后重启 web 应用生效。
-
-Or the manual equivalent: add `dsh-novel-writer` to the `dsh.profile.bundles` array in the profile's
-`package.json`, and link this package into the profile `node_modules` (on Windows, `mklink /J`).
-Restart the web app after installing.
-
-### （可选）安装技能 / (Optional) Install the Skill
-
-把 `skills/novel-writing` 整个文件夹复制到工作区 `.dsh/skills/` 下，新会话即出现 `novel-writing` 技能：
-
-Copy the whole `skills/novel-writing` folder into your workspace `.dsh/skills/`; a new session will surface the `novel-writing` skill:
-
+dsh plugin --profile web add D:/Deep\ Seek插件库/novel-writer
 ```
-<workspace>/.dsh/skills/novel-writing/SKILL.md
-```
-
----
 
-## 配置 / Configuration
+或手动等价操作：在 profile 的 `package.json` 的 `dsh.profile.bundles` 中加入
+`dsh-novel-writer`，并在 profile `node_modules` 中链接本包。安装后重启 web 应用生效。
 
-插件 `config` 支持 `root`：章节库根目录（默认取**会话工作区**，即 `novels/` 所在位置）。
-在 profile 的 `cordis.patch.yml` 中可覆盖：
+## 配置
 
-The plugin `config` supports `root`: the library root directory (defaults to the **session workspace** where `novels/` lives). Override it in the profile's `cordis.patch.yml`:
+插件 config 支持 `root`：章节库根目录（默认取会话工作区，即 `novels/` 所在位置）。
+在 profile 的 `cordis.patch.yml` 中可覆盖（顶层数组元素直接是条目，无需 `patch:` 包装）：
 
 ```yaml
-- patch:
-    - id: novel-writer
-      config:
-        root: 'D:/我的小说库'
-```
-
----
-
-## 章节库约定 / Library Convention
-
+- id: novel-writer
+  config:
+    root: 'D:/我的小说库'
 ```
-<workspace or root>/novels/<书名>/
-├── 第01章.md          # 或 .txt / .markdown
-└── 原稿件-单章-…第一章.txt   # 序号在任意位置、中文数字均可识别
-```
-
-支持的命名与编码 / Supported naming & encoding:
 
-- 章号任意位置：`第01章.md`、`01-标题.md`、`原稿件-单章-…第一章.txt`、`原稿件-单章-第25章 .txt`
-- 阿拉伯数字 + 中文数字（第一章/第十四章/第三十章），自动按章号排序
-- 编码自动探测：UTF-8（含/不含 BOM）、UTF-16 LE/BE（含 BOM 或启发式）、GBK/GB18030（无 BOM）
+### stylePattern 开关（句式模式仿写拓展）
 
----
+`stylePattern`（布尔，**默认 false 关闭**）：控制 `novel_style_pattern` 工具与
+"句式模式仿写"提示词——分析原文陈述/反问/心理/对话等句子的排列节奏，引导续写时保持相近
+叙事节奏。
 
-## 安全说明 / Security Notes
+> ⚠️ **已知风险**：该功能可能让整体文风变得更僵硬（机械套用句式模板）。默认关闭；
+> 开启后模型侧也内置了"模式是参考、僵硬时优先自然表达"的约束，但仍建议按需使用。
 
-- 仅使用 Node 内置模块，无第三方运行时依赖、无网络请求、无 shell 执行。
-- 所有文件读写均限定在章节库根目录下，并通过 `sanitizeSegment` 阻止路径穿越（拒绝 `.`/`..` 与 `\`/`/`）。
-- 读取设有上限（单次最多 400 行 / 2 万字符），保护模型上下文。
+**Web 设置开关（推荐）**：重启 web 后，打开 **设置 > 插件配置**，会看到
+「小说写作助手 novel-writer」卡片，勾选「开启句式模式仿写（stylePattern）」即可——
+改动写入 `$DSH_HOME/novel-writer.json`，**即时生效，无需重启**（工具未开启时调用会返回明确提示）。
 
-- Uses only Node built-in modules: no third-party runtime deps, no network calls, no shell execution.
-- All file reads/writes are confined to the library root, with `sanitizeSegment` blocking path traversal (rejects `.`/`..` and `\`/`/`).
-- Reads are capped (400 lines / 20k chars per call) to protect the model's context window.
+也可在 profile 的 `cordis.patch.yml` 中配置（顶层数组元素直接是条目）：
 
----
-
-<!-- ENGLISH -->
-
-## English
+```yaml
+- id: novel-writer
+  config:
+    root: ''
+    stylePattern: true
+```
 
-`dsh-novel-writer` is a self-contained **DSH (Cordis) bundle plugin** for novel-writing assistance, with **no third-party dependencies** (Node built-ins only). See the sections above for features, tools, install, config, and security notes. MIT licensed.
+开关判定优先级：`$DSH_HOME/novel-writer.json` 中的持久化值 或 loader 配置的 `stylePattern`，任一为 true 即开启。

package/client.js

@@ -0,0 +1,72 @@
+/**
+ * dsh-novel-writer 客户端设置卡片。
+ *
+ * 注册进官方设置页的「插件配置」槽位（settings.plugin.item），提供
+ * stylePattern（句式模式仿写）开关。读写走宿主端的 /novel-writer-config
+ * 同源路由，绕开 rc.6 的 settings namespace 白名单限制；改动即时生效。
+ *
+ * 格式说明（与官方客户端插件一致）：
+ *   - window.__ModuleLoader__.load({ id: <包名>, factory })
+ *   - factory 返回 { name, inject, apply } —— inject 声明本插件使用的服务名
+ *     （缺少 inject 声明会导致 ctx.locale / ctx.slots 等被服务门禁拦截）。
+ */
+window.__ModuleLoader__.load({
+  id: "dsh-novel-writer",
+  factory: (require) => {
+    const React = require("react");
+    const { createElement: h, useEffect, useState } = React;
+
+    const name = "novel-writer-config";
+    const inject = ["slots"];
+
+    function NovelWriterConfigCard() {
+      const [enabled, setEnabled] = useState(null);
+      const [busy, setBusy] = useState(false);
+      useEffect(() => {
+        let alive = true;
+        fetch("/novel-writer-config", { method: "GET" })
+          .then((r) => r.json())
+          .then((j) => { if (alive) setEnabled(j.stylePattern === true); })
+          .catch(() => { if (alive) setEnabled(false); });
+        return () => { alive = false; };
+      }, []);
+      const toggle = (next) => {
+        setBusy(true);
+        fetch("/novel-writer-config", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ stylePattern: next })
+        })
+          .then((r) => r.json())
+          .then((j) => setEnabled(j.stylePattern === true))
+          .catch(() => {})
+          .finally(() => setBusy(false));
+      };
+      return h("div", { style: { padding: "12px 0", borderBottom: "1px solid var(--dsw-alias-border-l2, #e5e7eb)" } },
+        h("div", { style: { fontWeight: 600 } }, "小说写作助手 novel-writer"),
+        h("div", { style: { color: "var(--dsw-alias-text-l2, #888)", fontSize: 12, margin: "4px 0 8px" } },
+          "句式模式仿写：分析原文陈述/反问/心理/对话等句子的排列节奏来模仿文风。⚠️ 可能让文风变僵硬，默认关闭；改动即时生效。"),
+        h("label", { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer" } },
+          h("input", {
+            type: "checkbox",
+            checked: enabled === true,
+            disabled: busy || enabled === null,
+            onChange: (e) => toggle(e.target.checked)
+          }),
+          h("span", null, "开启句式模式仿写（stylePattern）")
+        )
+      );
+    }
+
+    function apply(ctx) {
+      ctx.slots.inject("settings.plugin.item", () => ctx.slots.register({
+        name: "settings.plugin.item",
+        id: "novel-writer-config",
+        order: 105,
+        inject: () => ({})
+      }, NovelWriterConfigCard));
+    }
+
+    return { name, inject, apply };
+  }
+});

package/lib/index.js

@@ -17,8 +17,11 @@
  * 注意：output.schema 必须使用标准 JSON Schema 子集（required 是对象层的
  * 字符串数组），与 tools.register() 的 assertSupportedJsonSchema 一致。
  */
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, extname, join, sep } from "node:path";
+import { homedir } from "node:os";
+import { TYPE_CODES, analyzePattern, buildGuidance, classifySentence, compressSequence, ratioMap, splitSentences } from "./pattern.js";
 
 const name = "novel-writer";
 const inject = ["tools", "systemPrompt"];
@@ -85,6 +88,277 @@ function cleanChapterTitle(stem) {
     .trim();
 }
 
+// ---- 原稿件导入 / 自动分类 ----
+
+/** 文件名中的噪音词（前缀/独立成段，不构成书名）。 */
+const IMPORT_NOISE = new Set(["原稿件", "单章", "调教计划", "未命名", "新建文档", "草稿", "无题", "正文", "手稿"]);
+
+/** 从文件名提取书名候选：去扩展名、章号标记、噪音词与分隔符。失败返回 void 0。 */
+function bookNameFromFileName(fileName) {
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const parts = stem
+    .replace(/第?(\d{1,4})[章回话]/g, " ")
+    .replace(/第[零一二三四五六七八九十百两]+[章回话]/g, " ")
+    .replace(LEADING_NUMBER, " ")
+    .split(/[\s._\-—~]+/)
+    .map((p) => p.trim())
+    .filter((p) => p !== "" && !IMPORT_NOISE.has(p));
+  const name = parts.join(" ").trim();
+  return name === "" ? void 0 : name;
+}
+
+/** 从文件头内容提取书名候选：跳过噪音行，只认"含章号标记的标题行"（如"吸血鬼萝莉的魅魔系统 第一章"），
+ *  清理章号后作为书名候选；找不到则返回 void 0（该文件将落入"未分类"组，由 AI 判断归属）。 */
+function bookNameFromContent(text) {
+  const lines = String(text).split(/\r?\n/).slice(0, 12);
+  for (const raw of lines) {
+    const line = raw.replace(/^#+\s*/, "").replace(/^\uFEFF/, "").trim();
+    if (line === "") continue;
+    if (IMPORT_NOISE.has(line)) continue;
+    const hasChapterMark = /第?(\d{1,4})[章回话]|第[零一二三四五六七八九十百两]+[章回话]/.test(line);
+    if (hasChapterMark) {
+      const cleaned = cleanChapterTitle(line);
+      if (cleaned !== "") return cleaned;
+    }
+    // 无章号标记的行不是章节标题行（可能是正文/随笔），跳过继续找
+  }
+  return void 0;
+}
+
+/** 扫描一个目录（递归）下的章节类文本文件，返回相对路径列表。 */
+async function collectTextFiles(dir, recursive, out = [], prefix = "") {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const rel = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (recursive) await collectTextFiles(join(dir, entry.name), recursive, out, rel);
+    } else if (entry.isFile() && CHAPTER_EXTENSIONS.has(extname(entry.name).toLowerCase())) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+
+function registerNovelImport(ctx, config) {
+  ctx.tools.register({
+    name: "novel_import",
+    description: "扫描一个存放大量原稿件文本的文件夹，自动识别并分类其中包含的小说章节：从文件名与文件头内容双通道提取书名候选与章号，聚合成分组建议；可执行复制/移动到章节库 novels/<书名>/ 分类存放。用于把混杂的多本小说稿件一键整理进书库。",
+    parameters: {
+      type: "object",
+      properties: {
+        src: { type: "string", description: "待导入的原稿件文件夹路径（可含多本小说的章节文本，支持子文件夹）。" },
+        mode: { type: "string", enum: ["scan", "apply"], description: "scan=只分析并返回分组建议（默认，不写盘）；apply=按分组执行导入。" },
+        book: { type: "string", description: "apply 时可选：强制把所有（或 files 指定的）文件归入该书名，用于合并异名同书（如\"萝莉/幼女\"两个书名候选实为同一本），或把\"未分类\"中的文件指定归属。" },
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "apply 时可选：只处理这些文件（相对 src 的路径，如\"旧稿/第一章.txt\"）。省略则处理全部扫描到的文件。"
+        },
+        move: { type: "boolean", description: "apply 时是否移动原文件（默认 false=复制，源文件保留）。" },
+        recursive: { type: "boolean", description: "是否递归扫描子文件夹。默认 true。" },
+        root: { type: "string", description: "章节库根目录（含 novels 子目录）。默认取会话工作区。" }
+      },
+      required: ["src"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          src: { type: "string" },
+          mode: { type: "string" },
+          groups: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                book: { type: "string" },
+                from: { type: "string", enum: ["file", "content", "forced"] },
+                files: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                      file: { type: "string" },
+                      chapter: { type: "integer" },
+                      title: { type: "string" }
+                    },
+                    required: ["file"]
+                  }
+                }
+              },
+              required: ["book", "files"]
+            }
+          },
+          skipped: {
+            type: "array",
+            items: { type: "string" }
+          },
+          imported: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                book: { type: "string" },
+                file: { type: "string" },
+                path: { type: "string" }
+              },
+              required: ["book", "file", "path"]
+            }
+          }
+        },
+        required: ["src", "mode", "groups", "skipped", "imported"]
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: formatImport(value)
+      }]
+    },
+    async execute(args, exec) {
+      const src = requiredString(args, "src");
+      const mode = args?.mode === "apply" ? "apply" : "scan";
+      const forcedBook = optionalString(args, "book");
+      const onlyFiles = Array.isArray(args?.files) && args.files.length > 0
+        ? new Set(args.files.map((f) => String(f).replace(/\\/g, "/").replace(/^\.?\//, "")))
+        : null;
+      const move = args?.move === true;
+      const recursive = args?.recursive !== false;
+      const root = resolveRoot(config, args, exec);
+      const files = await collectTextFiles(src, recursive);
+      const skipped = [];
+      const rows = [];
+      for (const rel of files) {
+        const norm = rel.replace(/\\/g, "/");
+        if (onlyFiles !== null && !onlyFiles.has(norm)) continue;
+        const full = join(src, rel);
+        let info;
+        try {
+          info = await stat(full);
+        } catch {
+          continue;
+        }
+        if (!info.isFile()) continue;
+        const fileName = basename(rel);
+        let text = "";
+        try {
+          text = await readTextFile(full, exec);
+        } catch {
+          skipped.push(rel);
+          continue;
+        }
+        if (text.trim() === "") {
+          skipped.push(rel);
+          continue;
+        }
+        const nameFromFile = bookNameFromFileName(fileName);
+        const nameFromContent = bookNameFromContent(text);
+        rows.push({
+          file: rel,
+          chapter: parseChapterNumber(fileName),
+          nameFromFile,
+          nameFromContent
+        });
+      }
+      // 分组：forcedBook > 文件名候选 > 内容候选 > 未分类。
+      // 关键规则：只有"疑似章节文件"（文件名或内容含章号标记）才参与正常分组；
+      // 无章号标记的文件（随笔/损坏/无关文档）一律归入"未分类"，由 AI 判断是否导入。
+      const groupMap = new Map();
+      const groupFrom = new Map();
+      for (const row of rows) {
+        const isChapterFile = row.chapter !== void 0 || row.nameFromContent !== void 0;
+        let book;
+        let from;
+        if (forcedBook !== void 0) {
+          book = forcedBook;
+          from = "forced";
+        } else if (isChapterFile && row.nameFromFile !== void 0) {
+          book = row.nameFromFile;
+          from = "file";
+        } else if (isChapterFile && row.nameFromContent !== void 0) {
+          book = row.nameFromContent;
+          from = "content";
+        } else {
+          book = "未分类";
+          from = "content";
+        }
+        if (!groupMap.has(book)) {
+          groupMap.set(book, []);
+          groupFrom.set(book, from);
+        }
+        groupMap.get(book).push(row);
+      }
+      const groups = [];
+      for (const [book, rows2] of groupMap) {
+        rows2.sort((a, b) => (a.chapter ?? Number.MAX_SAFE_INTEGER) - (b.chapter ?? Number.MAX_SAFE_INTEGER) || a.file.localeCompare(b.file));
+        groups.push({
+          book,
+          from: groupFrom.get(book),
+          files: rows2.map((r) => ({
+            file: r.file,
+            ...r.chapter === void 0 ? {} : { chapter: r.chapter },
+            ...r.nameFromContent === void 0 ? {} : { title: r.nameFromContent }
+          }))
+        });
+      }
+      groups.sort((a, b) => b.files.length - a.files.length || a.book.localeCompare(b.book));
+      // apply：复制/移动到 novels/<book>/
+      const imported = [];
+      if (mode === "apply") {
+        for (const group of groups) {
+          if (group.book === "未分类") continue;
+          const safeBook = sanitizeSegment(group.book, "book");
+          const destDir = join(novelsDir(root), safeBook);
+          await mkdir(destDir, { recursive: true });
+          for (const row of group.files) {
+            const srcFull = join(src, row.file);
+            const destFull = join(destDir, basename(row.file));
+            if (move) {
+              await copyFile(srcFull, destFull);
+              await rm(srcFull, { force: true });
+            } else {
+              await copyFile(srcFull, destFull);
+            }
+            imported.push({ book: safeBook, file: basename(row.file), path: destFull });
+          }
+        }
+      }
+      return { src, mode, groups, skipped, imported };
+    }
+  });
+}
+
+function formatImport(value) {
+  const lines = [`<path>${value.src}</path>`, `<type>novel-import-${value.mode}</type>`, `<content>`, ""];
+  lines.push(`扫描结果：${value.groups.reduce((n, g) => n + g.files.length, 0)} 个文件 → ${value.groups.length} 组` +
+    (value.skipped.length > 0 ? `（跳过 ${value.skipped.length} 个无法读取的文件）` : ""));
+  for (const group of value.groups) {
+    const from = group.from === "file" ? "文件名" : group.from === "content" ? "文件头内容" : "强制指定";
+    lines.push("");
+    lines.push(`[${group.book}] (来自${from}, ${group.files.length} 个文件)`);
+    for (const f of group.files) {
+      const ch = f.chapter === void 0 ? "?" : `第${f.chapter}章`;
+      lines.push(`  - ${ch} ${f.file}`);
+    }
+  }
+  if (value.imported.length > 0) {
+    lines.push("");
+    lines.push(`已导入 ${value.imported.length} 个文件：`);
+    for (const item of value.imported) lines.push(`  - novels/${item.book}/${item.file}`);
+  }
+  lines.push("", "</content>");
+  return lines.join("\n");
+}
+
 /** 中文虚词/功能字黑名单：不参与关键词统计。 */
 const CJK_STOP_CHARS = new Set(
   "的了是在有和就都而于及与或这那之其以被把让向着过也还又但更最很从对为等啊吧呢吗嗯哦呀哈啦么个中上下前后左右来去出进到说想看要会能可没有不".split("")
@@ -685,6 +959,162 @@ Created 第${String(value.number).padStart(2, "0")}章 (${value.chars} chars)
   });
 }
 
+/** 句式模式分析工具（stylePattern 开关开启时注册）。 */
+function registerNovelStylePattern(ctx, config) {
+  ctx.tools.register({
+    name: "novel_style_pattern",
+    description: "分析一部作品（或单章）的句式排列模式：把句子分为陈述/环境/心理/对话/疑问/反问/感叹七类，输出各类占比、高频句式组合与按章节的压缩排列序列，用于模仿原文的叙事节奏。",
+    parameters: {
+      type: "object",
+      properties: {
+        book: { type: "string", description: "书名。" },
+        chapter: { type: "string", description: "可选。只分析该章节；省略则分析全书。" },
+        top: { type: "integer", description: "返回的高频句式组合数量。默认 10。" },
+        root: { type: "string", description: "章节库根目录。默认取会话工作区。" }
+      },
+      required: ["book"],
+      additionalProperties: false
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          book: { type: "string" },
+          scope: { type: "string" },
+          totalSentences: { type: "integer" },
+          counts: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              S: { type: "integer" }, ENV: { type: "integer" }, PSY: { type: "integer" },
+              DLG: { type: "integer" }, Q: { type: "integer" }, RQ: { type: "integer" }, EX: { type: "integer" }
+            },
+            required: ["S", "ENV", "PSY", "DLG", "Q", "RQ", "EX"]
+          },
+          ratios: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              S: { type: "integer" }, ENV: { type: "integer" }, PSY: { type: "integer" },
+              DLG: { type: "integer" }, Q: { type: "integer" }, RQ: { type: "integer" }, EX: { type: "integer" }
+            },
+            required: ["S", "ENV", "PSY", "DLG", "Q", "RQ", "EX"]
+          },
+          topPatterns: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                pattern: { type: "string" },
+                count: { type: "integer" }
+              },
+              required: ["pattern", "count"]
+            }
+          },
+          chapterPatterns: {
+            type: "array",
+            items: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                chapter: { type: "string" },
+                sequence: { type: "string" }
+              },
+              required: ["chapter", "sequence"]
+            }
+          },
+          guidance: { type: "string" }
+        },
+        required: ["book", "scope", "totalSentences", "counts", "ratios", "topPatterns", "chapterPatterns", "guidance"]
+      },
+      render: (_args, value) => [{
+        type: "text",
+        text: formatStylePattern(value)
+      }]
+    },
+    async execute(args, exec) {
+      const styleOn = config?.stylePattern === true || readStyleEnabled();
+      assert(styleOn, "句式模式仿写（novel_style_pattern）当前未开启：可在 Web 设置 > 插件配置 中打开 novel-writer 的 stylePattern 开关后重试。");
+      const book = sanitizeSegment(requiredString(args, "book"), "book");
+      const chapterArg = optionalString(args, "chapter");
+      const top = optionalInt(args, "top", 1, 50, 10);
+      const root = resolveRoot(config, args, exec);
+      const dir = bookDir(root, book);
+      const chapters = await scanChapters(dir);
+      assert(chapters.length > 0, `book "${book}" has no chapter files`);
+      const selected = chapterArg !== void 0 ? [findChapter(chapters, chapterArg)] : chapters;
+      assert(selected[0] !== void 0, `cannot find chapter "${chapterArg}" in book "${book}"`);
+      const scope = chapterArg !== void 0 ? selected[0].file : `全书 ${chapters.length} 章`;
+      const chapterPatterns = [];
+      const allCodes = [];
+      const allCounts = {};
+      for (const code of TYPE_CODES) allCounts[code] = 0;
+      for (const chapter of selected) {
+        const text = await readFile(join(dir, chapter.file), { encoding: "utf8", signal: exec.signal });
+        const local = analyzePattern(text, { top });
+        for (const code of TYPE_CODES) allCounts[code] += local.counts[code];
+        allCodes.push(...local.codes);
+        chapterPatterns.push({
+          chapter: chapter.file,
+          sequence: local.sequence
+        });
+      }
+      const topPatterns = (() => {
+        const grams = new Map();
+        for (let i = 0; i + 2 < allCodes.length; i += 1) {
+          const key = allCodes.slice(i, i + 3).join("→");
+          grams.set(key, (grams.get(key) ?? 0) + 1);
+        }
+        return [...grams.entries()]
+          .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+          .slice(0, top)
+          .map(([pattern, count]) => ({ pattern, count }));
+      })();
+      const ratios = ratioMap(allCounts, allCodes.length);
+      const guidance = buildGuidance(ratios, topPatterns, chapterPatterns);
+      return {
+        book,
+        scope,
+        totalSentences: allCodes.length,
+        counts: allCounts,
+        ratios,
+        topPatterns,
+        chapterPatterns,
+        guidance
+      };
+    }
+  });
+}
+
+function formatStylePattern(value) {
+  const typeName = { S: "陈述", ENV: "环境", PSY: "心理", DLG: "对话", Q: "疑问", RQ: "反问", EX: "感叹" };
+  const lines = [
+    `<path>novels/${value.book}</path>`,
+    `<type>novel-style-pattern</type>`,
+    `<content>`,
+    `统计范围: ${value.scope}（共 ${value.totalSentences} 句）`,
+    "",
+    "句式分布: " + Object.entries(value.ratios)
+      .filter(([, r]) => r > 0)
+      .map(([code, r]) => `${typeName[code]}( ${code} ) ${r}%`)
+      .join(" · "),
+    "高频句式组合: " + (value.topPatterns.length > 0
+      ? value.topPatterns.slice(0, 5).map((p) => `${p.pattern} ×${p.count}`).join("、")
+      : "（样本过短）"),
+    "",
+    "章节节奏（S=陈述 ENV=环境 PSY=心理 DLG=对话 Q=疑问 RQ=反问 EX=感叹）:",
+    ...value.chapterPatterns.slice(0, 12).map((c) => `  ${c.chapter}: ${c.sequence}`),
+    "",
+    "仿写建议:",
+    ...value.guidance.split("\n").map((line) => `  ${line}`),
+    "",
+    "</content>"
+  ];
+  return lines.join("\n");
+}
+
 /** 系统提示词：小说写作工作流（需求 1-3 的模型侧约定）。 */
 const WORKFLOW_TEXT = [
   "【小说写作助手 novel-writer】",
@@ -695,7 +1125,89 @@ const WORKFLOW_TEXT = [
   "   以及用 novel_keywords 提取的高频关键词（作者词汇偏好与意象母题），并说明这些手法/关键词在具体章节中的例证。",
   "3. 续写 / 辅助写作时：先通读最近的章节（保持人物、时间线、情节伏笔、文风与已提炼的关键词一致），再动笔。",
   "   新章节写入 novels/<书名>/ 文件夹：用 novel_new_chapter 创建章节文件，或直接用 write 工具写文件。",
-  "4. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。"
+  "4. 每次续写前先简述：上一章结尾状态 → 本章目标 → 写作计划，再给出正文。",
+  "5. 导入/整理原稿件时：用 novel_import 扫描存放多本小说稿件的文件夹（src），先以 scan 模式查看分组建议，",
+  "   若发现异名同书（如\"萝莉/幼女\"实为同一本），用 book 参数强制合并后以 apply 模式导入到 novels/<书名>/ 分类存放。"
+].join("\n");
+
+/**
+ * stylePattern 开关的持久化：独立的配置文件（$DSH_HOME/novel-writer.json）。
+ * Web 设置卡片通过 /novel-writer-config 路由读写它；工具执行时实时读取，
+ * 因此 Web 里开关后立即生效（无需重启）。
+ */
+function styleConfigPath() {
+  const home = process.env.DSH_HOME && process.env.DSH_HOME.trim() !== "" ? process.env.DSH_HOME : join(homedir(), ".dsh");
+  return join(home, "novel-writer.json");
+}
+/** 读取持久化的 stylePattern 开关（true = 开启）。文件缺失/损坏一律视为关。 */
+function readStyleEnabled() {
+  try {
+    if (!existsSync(styleConfigPath())) return false;
+    const parsed = JSON.parse(readFileSync(styleConfigPath(), "utf8"));
+    return parsed?.stylePattern === true;
+  } catch {
+    return false;
+  }
+}
+/** 写入持久化的 stylePattern 开关。 */
+function writeStyleEnabled(enabled) {
+  const path = styleConfigPath();
+  writeFileSync(path, JSON.stringify({ stylePattern: enabled === true }, null, 2) + "\n", "utf8");
+}
+/**
+ * 在 web profile 注册 /novel-writer-config 配置路由（设置卡片的读写后端）。
+ * 用可选注入：headless 等无 webServer 的 profile 直接跳过。
+ */
+function registerStyleConfigRoute(ctx) {
+  ctx.inject(["webServer"], (wctx) => {
+    wctx.webServer.register({
+      kind: "exact",
+      path: "/novel-writer-config",
+      handler: (req, res) => {
+        const send = (status, body) => {
+          const payload = JSON.stringify(body);
+          res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+          res.end(payload);
+        };
+        if (req.method === "GET") {
+          send(200, { stylePattern: readStyleEnabled() });
+          return;
+        }
+        if (req.method === "POST") {
+          let raw = "";
+          req.on("data", (chunk) => {
+            raw += chunk;
+            if (raw.length > 4096) req.destroy();
+          });
+          req.on("end", () => {
+            try {
+              const body = JSON.parse(raw || "{}");
+              if (typeof body.stylePattern !== "boolean") {
+                send(400, { error: "stylePattern must be a boolean" });
+                return;
+              }
+              writeStyleEnabled(body.stylePattern);
+              send(200, { stylePattern: body.stylePattern });
+            } catch {
+              send(400, { error: "invalid JSON body" });
+            }
+          });
+          return;
+        }
+        send(405, { error: "method not allowed" });
+      }
+    });
+  });
+}
+
+/** 句式模式仿写提示词（stylePattern 开启时注入；含风险说明）。 */
+const STYLE_GUIDANCE_TEXT = [
+  "【句式模式仿写 novel_style_pattern（受 stylePattern 开关控制）】",
+  "1. 该功能默认关闭；若调用 novel_style_pattern 返回「未开启」提示，说明用户未在 Web 设置 > 插件配置 中开启 stylePattern，此时不要强行模仿句式，按普通流程写作即可。",
+  "2. 开启时：仿写/续写前，先用 novel_style_pattern 分析原文的句式排列：陈述/环境/心理/对话/疑问/反问/感叹七类句子的占比、高频组合与按章节的节奏序列。",
+  "3. 写作时尽量贴近原文的句式节奏：陈述句密度、心理描写出现的时机与位置、反问句的使用频率、对话与叙事的穿插比例、环境描写的点缀节奏。",
+  "4. 重要风险提示：句式模式是「参考节奏」，不是「模板套用」。若机械复刻导致句子僵硬、重复、模式化或失去自然感，必须优先回归自然表达；",
+  "   适度偏离原文模式是允许且更优的选择。分析报告中的模式代码（S/ENV/PSY/DLG/Q/RQ/EX）只用来指导句式选择，不要直接出现在正文或报告里。"
 ].join("\n");
 
 function apply(ctx, config = {}) {
@@ -704,11 +1216,22 @@ function apply(ctx, config = {}) {
   registerNovelRead(ctx, config);
   registerNovelKeywords(ctx, config);
   registerNovelNewChapter(ctx, config);
+  registerNovelImport(ctx, config);
   ctx.systemPrompt.section({
     name: "novel-writing",
     order: 150,
     text: WORKFLOW_TEXT
   });
+  // stylePattern 开关：默认关闭（规避机械套用导致文风僵硬的已知风险）。
+  // 工具常注册，执行时实时读取开关状态（config.stylePattern 或 $DSH_HOME/novel-writer.json），
+  // 因此 Web 设置 > 插件配置 里的开关改动即时生效，无需重启。
+  registerNovelStylePattern(ctx, config);
+  registerStyleConfigRoute(ctx);
+  ctx.systemPrompt.section({
+    name: "novel-writing-style",
+    order: 151,
+    text: STYLE_GUIDANCE_TEXT
+  });
 }
 
 export { apply, inject, name };

package/lib/pattern.js

@@ -0,0 +1,125 @@
+/**
+ * 句式模式分析引擎 — 纯函数、零依赖。
+ *
+ * 把正文拆成句子，按启发式规则分类：
+ *   S   陈述/叙事   ENV 环境描写   PSY 心理描写   DLG 对话
+ *   Q   疑问句      RQ  反问句     EX  感叹句
+ * 然后输出：各类占比、高频句式组合（三元组）、按章节的压缩排列序列。
+ *
+ * 这是给模型做"风格节奏参考"的软信号，不是精确语法标注：启发式分类
+ * 允许有误差，模型应把它当节奏参考而非硬约束（见插件提示词中的风险说明）。
+ */
+
+/** 全部句式代码（顺序即展示顺序）。 */
+export const TYPE_CODES = ["S", "ENV", "PSY", "DLG", "Q", "RQ", "EX"];
+
+/** 对话：句子含中文/英文引号即视为对话（优先于其它类型）。 */
+const DIALOGUE_RE = /[“”"「」『』‘’]/;
+/** 疑问句：以问号结尾。 */
+const INTERROGATIVE_RE = /[？?]$/;
+/** 反问句：疑问句且含典型反问标记词。 */
+const RHETORICAL_RE = /难道|岂|何尝|焉能|怎能|怎么会|哪里|哪儿|哪有|不是吗|莫非|不成|何必|未必|何苦|奈何/;
+/** 感叹句：以感叹号结尾。 */
+const EXCLAMATION_RE = /[！!]$/;
+/** 心理描写标记词（较保守，避免把常见动词"想/知道"误判为心理）。 */
+const PSY_RE = /心里|心中|心想|心道|暗自|暗暗|不禁|忍不住|觉得|感到|感觉|仿佛|似乎|好像|但愿|后悔|担心|害怕|怀疑|意识到|没想到|没料到|怔了怔|愣住|内心|回忆|想念|寒了|一沉|一紧|倒吸/;
+/** 环境描写标记词（天色/天气/景物类名词）。 */
+const ENV_RE = /夜色|月光|晨光|暮色|夕阳|黄昏|清晨|深夜|夜空|天边|星光|灯火|细雨|微风|大雨|暴雨|风雪|薄雾|浓雾|云层|远山|山影|河面|湖水|街道|巷子|烛火|窗|雨声|风声|树影|落叶|残雪|霜|天色/;
+
+/** 把正文拆成句子（保留句末标点；无标点的尾部片段也算一句）。 */
+export function splitSentences(text) {
+  const sentences = [];
+  const re = /[^。！？…!?]*[。！？…!?]/g;
+  let match;
+  let last = 0;
+  while ((match = re.exec(text)) !== null) {
+    const sentence = match[0].trim();
+    if (sentence.length > 0) sentences.push(sentence);
+    last = match.index + match[0].length;
+  }
+  const tail = text.slice(last).trim();
+  if (tail.length > 0) sentences.push(tail);
+  return sentences;
+}
+
+/** 单句分类（优先级：对话 > 疑问/反问 > 感叹 > 心理 > 环境 > 陈述）。 */
+export function classifySentence(sentence) {
+  if (DIALOGUE_RE.test(sentence)) return "DLG";
+  if (INTERROGATIVE_RE.test(sentence)) return RHETORICAL_RE.test(sentence) ? "RQ" : "Q";
+  if (EXCLAMATION_RE.test(sentence)) return "EX";
+  if (PSY_RE.test(sentence)) return "PSY";
+  if (ENV_RE.test(sentence)) return "ENV";
+  return "S";
+}
+
+/** 压缩排列序列：S×8 ENV×2 PSY×3 …（跑长编码，直观展示句式先后排列）。 */
+export function compressSequence(codes, maxRuns = 48) {
+  const runs = [];
+  for (const code of codes) {
+    const last = runs[runs.length - 1];
+    if (last !== void 0 && last.code === code) last.n += 1;
+    else runs.push({ code, n: 1 });
+  }
+  const parts = runs.slice(0, maxRuns).map((run) => `${run.code}×${run.n}`);
+  if (runs.length > maxRuns) parts.push(`…(共${runs.length}段)`);
+  return parts.join(" ");
+}
+
+/** 各类占比（整数百分比）。 */
+export function ratioMap(counts, total) {
+  const out = {};
+  for (const code of TYPE_CODES) out[code] = total > 0 ? Math.round((counts[code] / total) * 100) : 0;
+  return out;
+}
+
+/**
+ * 分析一段正文的句式模式。
+ * @param text - 正文。
+ * @param opts - { top: 高频组合条数（默认 10）, maxSentences: 采样上限（默认 4000） }。
+ * @returns { codes, counts, topPatterns, sequence, ratios }
+ */
+export function analyzePattern(text, opts = {}) {
+  const top = opts.top ?? 10;
+  const maxSentences = opts.maxSentences ?? 4000;
+  const sentences = splitSentences(text).slice(0, maxSentences);
+  const codes = sentences.map(classifySentence);
+  const counts = {};
+  for (const code of TYPE_CODES) counts[code] = 0;
+  for (const code of codes) counts[code] += 1;
+  const grams = new Map();
+  for (let i = 0; i + 2 < codes.length; i += 1) {
+    const key = codes.slice(i, i + 3).join("→");
+    grams.set(key, (grams.get(key) ?? 0) + 1);
+  }
+  const topPatterns = [...grams.entries()]
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .slice(0, top)
+    .map(([pattern, count]) => ({ pattern, count }));
+  return {
+    codes,
+    counts,
+    topPatterns,
+    sequence: compressSequence(codes),
+    ratios: ratioMap(counts, codes.length)
+  };
+}
+
+/** 生成给模型的风格节奏建议（紧凑文本）。 */
+export function buildGuidance(ratios, topPatterns, chapterSequences) {
+  const ratioText = TYPE_CODES
+    .filter((code) => ratios[code] > 0)
+    .map((code) => `${code} ${ratios[code]}%`)
+    .join(" · ");
+  const patternText = topPatterns.length > 0
+    ? topPatterns.slice(0, 5).map((p) => `${p.pattern} ×${p.count}`).join("、")
+    : "（样本过短，未形成高频组合）";
+  const lines = [
+    `句式分布：${ratioText}`,
+    `高频句式组合：${patternText}`
+  ];
+  if (chapterSequences.length > 0) {
+    lines.push("章节节奏（压缩序列，S=陈述 ENV=环境 PSY=心理 DLG=对话 Q=疑问 RQ=反问 EX=感叹）：");
+    for (const item of chapterSequences.slice(0, 12)) lines.push(`  ${item.chapter}: ${item.sequence}`);
+  }
+  return lines.join("\n");
+}

package/package.json

@@ -1,40 +1,32 @@
 {
   "name": "dsh-novel-writer",
-  "version": "0.2.0",
-  "description": "小说写作助手插件：章节库管理、剧情/写作手法/高频关键词分析、续写辅助（支持任意位置章号、中文数字、UTF-8/UTF-16/GBK 编码自动探测）",
+  "version": "0.4.0",
+  "description": "小说写作助手插件：章节库管理、剧情/写作手法/高频关键词分析、续写辅助、原稿件批量导入自动分类、句式模式仿写（stylePattern 开关，Web 设置可调）",
   "type": "module",
   "main": "lib/index.js",
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "lib",
-    "skills",
+    "client.js",
     "cordis.patch.yml",
-    "INSTALL.md",
     "README.md"
   ],
-  "keywords": [
-    "dsh",
-    "cordis",
-    "deepseek-harness",
-    "plugin",
-    "novel",
-    "writing",
-    "fiction",
-    "chapters"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/siweina/dsh-novel-writer.git"
-  },
-  "homepage": "https://github.com/siweina/dsh-novel-writer",
-  "bugs": {
-    "url": "https://github.com/siweina/dsh-novel-writer/issues"
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
   },
-  "author": "siweina",
-  "license": "MIT",
-  "dependencies": {}
+  "dependencies": {},
+  "license": "MIT"
 }

package/INSTALL.md

@@ -1,110 +0,0 @@
-# dsh-novel-writer v0.2.0 — 跨设备安装指南
-
-本目录是一个**完整的、自包含的插件分发件**，零第三方依赖（仅 Node 内置模块）。
-将其复制到任何安装了 DSH（DeepSeek Harness）的设备即可使用，无需联网下载任何依赖。
-
-```
-dsh-novel-writer-v0.2.0/
-├── lib/index.js           # 插件本体（含全部修复，见下文"版本记录"）
-├── package.json           # 包定义（bundle patch 指向 cordis.patch.yml）
-├── cordis.patch.yml       # 挂载插件到 loader 树
-├── README.md              # 功能与工具说明
-└── skills/
-    └── novel-writing/
-        └── SKILL.md       # 可选：小说写作技能（增强 AI 工作流）
-```
-
----
-
-## 一、安装插件
-
-### 方式 A：dsh CLI（推荐）
-
-把整个文件夹放到目标设备的任意位置（例如 `D:/tools/dsh-novel-writer`），然后：
-
-```sh
-dsh plugin --profile web add D:/tools/dsh-novel-writer
-```
-
-### 方式 B：手动等价操作
-
-1. 把本文件夹（或链接）放入 profile 的 `node_modules`：
-
-   ```sh
-   # 在 <DSH_HOME>/profiles/<profile名> 目录下
-   npm install D:/tools/dsh-novel-writer
-   # 或手动建立 junction 链接（Windows）：
-   # mklink /J <profile>\node_modules\dsh-novel-writer D:/tools/dsh-novel-writer
-   ```
-
-2. 编辑该 profile 的 `package.json`，在 `dsh.profile.bundles` 数组中加入：
-
-   ```json
-   "dsh-novel-writer"
-   ```
-
-3. 重启 web 应用，`novel_*` 系列工具即会注册到会话。
-
-> 插件的 `cordis.patch.yml` 由 bundle 自动应用（`package.json` 中
-> `dsh.bundle.patch` 已声明），无需手动往 profile 的 patch 文件里加条目。
-
-## 二、（可选）安装技能 SKILL.md
-
-技能用于增强 AI 的小说写作工作流提示（与插件工具配合使用）：
-
-- 把 `skills/novel-writing` 整个文件夹复制到工作区的 `.dsh/skills/` 下：
-
-  ```
-  <工作区>/.dsh/skills/novel-writing/SKILL.md
-  ```
-
-- 新会话中即会出现 `novel-writing` 技能。
-
-## 三、准备章节库
-
-章节库存放于**会话工作区**（或插件 config `root` 指定的目录）下的 `novels/` 文件夹：
-
-```
-<工作区>/novels/<书名>/
-├── 第01章.md          # 或 .txt / .markdown
-└── 原稿件-单章-…第一章.txt   # 序号在任意位置、中文数字均可识别
-```
-
-支持的文件命名与编码：
-
-- 章号任意位置：`第01章.md`、`01-标题.md`、`原稿件-单章-…第一章.txt`、`原稿件-单章-第25章 .txt`
-- 阿拉伯数字 + 中文数字（第一章/第十四章/第三十章），自动按章号排序
-- 编码自动探测：UTF-8（含/不含 BOM）、UTF-16 LE/BE（含 BOM 或启发式）、GBK/GB18030（无 BOM）
-
-## 四、验证安装
-
-安装并重启后，在会话中应能看到以下工具：`novel_books`、`novel_chapters`、
-`novel_read`、`novel_keywords`、`novel_new_chapter`。可先执行 `novel_books`
-确认能列出书库。
-
-若 `root` 需要指向其他目录（默认会话工作区），在 profile 的
-`cordis.patch.yml` 中覆盖：
-
-```yaml
-- patch:
-    - id: novel-writer
-      config:
-        root: 'D:/我的小说库'
-```
-
----
-
-## 版本记录
-
-### v0.2.0（本分发件）
-- **修复**：章节序号提取支持任意位置（含中文数字"第一章/第十四章/第三十章"），
-  修复 `原稿件-单章-…第N章` 命名下章号全部丢失、排序混乱、
-  `novel_read(book,"1")` 误命中"第31章"、`novel_new_chapter` 自动取号错乱的问题。
-- **新增**：文件编码自动探测（UTF-8 / UTF-16 LE/BE / GBK），
-  修复 UTF-16/GBK 章节文件读取乱码与字数统计错误的问题。
-- 通过 37 章全量压力测试（463,475 字 / 13,231 行，全书读取+关键词统计 < 200ms）。
-
-### v0.1.0（初始）
-- 章节库管理：novel_books / novel_chapters / novel_read
-- 分析：novel_keywords（中文二字词组 + 英文词）
-- 续写：novel_new_chapter（自动取下一个章号）

package/skills/novel-writing/SKILL.md

@@ -1,35 +0,0 @@
----
-name: novel-writing
-description: 小说写作助手工作流：管理章节库、分析剧情/写作手法/高频关键词、保持文风续写。当用户提到“小说/章节/续写/剧情分析/写作手法/关键词”时使用。
-user-invocable: true
----
-
-# 小说写作助手 (novel-writing)
-
-## 章节库约定
-
-- 所有小说章节存放在工作区 `novels/<书名>/` 文件夹下，每章一个 Markdown 文件，命名如 `第01章.md`、`第02章.md`。
-- 优先使用专用工具 `novel_books` / `novel_chapters` / `novel_read` 浏览与阅读；也可用 `glob`/`read` 直接查看。
-
-## 分析工作流
-
-1. `novel_books` 找到用户的作品；
-2. `novel_chapters` 查看章节结构与各章字数；
-3. `novel_read` 逐章通读（长章节用 offset/limit 分段读完）；
-4. `novel_keywords` 提取高频关键词（中文词组/单字 + 英文词），作为词汇偏好与意象母题的证据；
-5. 输出分析，至少覆盖三方面：
-   - **剧情脉络**：冲突、转折、悬念、伏笔、人物关系与目标；
-   - **写作手法**：叙事视角、节奏、对话、环境与细节描写、比喻意象、留白；
-   - **关键词与意象**：结合 novel_keywords 的结果，指出作者反复使用的词汇与意象，并引用具体章节佐证。
-
-## 续写工作流
-
-1. 先通读最近的章节（必要时读完全书），保持：人物设定、时间线、情节伏笔、文风、已提炼的关键词一致；
-2. 动笔前简述：上一章结尾状态 → 本章目标 → 写作计划；
-3. 用 `novel_new_chapter` 创建新章节文件，或直接用 `write` 工具写入 `novels/<书名>/第NN章.md`；
-4. 正文用中文，保持与原文一致的叙事风格与细节密度。
-
-## 注意事项
-
-- 用户放入章节文件的方式不限：可以自己复制进文件夹，也可以让 AI 用 `write`/`edit` 工具创建。
-- 分析结果与续写正文都应使用中文呈现。