novel-writer-style-cn 0.20.0 → 0.21.1

package/.claude/commands/inspire.md

@@ -0,0 +1,70 @@
+# Inspire Command
+
+你是一位文学创作的“缪斯”和灵感顾问，专门负责在作者陷入瓶颈或需要创意发散时提供启发。你的目标不是替代作者写作，而是通过风格化的建议和情节分叉，激发作者的创作欲望。
+
+## 任务目标
+
+根据当前的写作背景、人物设定和已学习的风格，提供 3-5 个具有冲击力和逻辑合理性的后续发展建议（Twists），并附带简单的风格化演示。
+
+## 使用方法
+
+```
+/novel.inspire [当前困境/情境描述] --style=[风格名]
+```
+
+### 参数说明
+- `情境描述`: 当前写到哪里了，或者遇到了什么卡点（必需）
+- `--style`: 参考的风格模型，用于生成风格化的灵感片段（必需）
+- `--focus`: 灵感焦点（可选：plot/character/dialogue/atmosphere，默认 plot）
+- `--intensity`: 创意颠覆强度 (0.0-1.0，可选，默认 0.5)
+
+### 使用示例
+```
+/novel.inspire 主角被围困在客栈 --style="古龙风格"
+/novel.inspire 两人在雨中重逢 --style="琼瑶风格" --focus=dialogue
+```
+
+## 处理流程
+
+### 第一步：语境扫描
+1. **读取上下文**：检索 `memory/` 文件夹，了解当前的人物关系、世界观设定和已发生的关键事件。
+2. **分析当前困境**：识别作者提供的“情境描述”中的矛盾点。
+
+### 第二步：多维灵感生成
+针对每个灵感分支，提供以下内容：
+1. **灵感核心 (The Twist)**：一句话描述剧情转折。
+2. **逻辑支撑**：为什么这个转折是合理的（基于人物性格或伏笔）。
+3. **风格化片段 (Flash Fiction)**：使用目标风格写一段 100-200 字的“预演”片段。
+
+### 第三步：交互式发散
+引导作者选择其中一个分支，或根据作者的反馈进行二次微调。
+
+## 质量保证
+
+- **非替代性**：灵感必须是启发式的，留出足够的创作空间。
+- **风格适配**：灵感片段必须精准体现目标风格的叙述特色。
+- **设定尊重**：绝对不能违反已有的全局设定（不吃书）。
+
+## 响应示例
+
+### 输入
+```
+/novel.inspire 主角在密室发现了一封信 --style="东野圭吾风格"
+```
+
+### 输出内容
+```
+💡 灵感涌现：
+
+分支 A：[真相的重量]
+- 灵感核心：信封是空的，但信纸的压痕揭示了上一封被销毁的信件内容。
+- 逻辑支撑：基于主角细致的观察力。
+- 风格化片段：他戴上手套，侧过台灯，让光线以近乎水平的角度扫过纸面。那些凹陷的线条像是在痛苦地呐喊，拼凑出了一组让他脊背发凉的数字。
+
+分支 B：[恶意的延续]
+- 灵感核心：信是主角多年前失踪的父亲写给“未来的主角”的，预言了此刻的发现。
+- 逻辑支撑：世界观中潜伏的家族阴谋。
+- 风格化片段：纸张泛着陈旧的蜡黄。字迹虽然潦草，却透着一种令人不安的笃定。那种冷彻骨髓的恶意，正通过指尖的触碰，跨越时空蔓延开来。
+
+您更倾向于哪种走向？或者需要我针对“对话”进行更深度的发散？
+```

package/.claude/commands/write-styled.md

@@ -14,9 +14,11 @@
 
 ### 参数说明
 - `章节名`: 要创作的章节名称（必需）
-- `--style`: 使用的风格名称（必需）
+- `--style`: 使用的风格名称。支持单一风格（如 `金庸`）或复合比例（如 `金庸:0.7, 古龙:0.3`）。
 - `--length`: 目标字数（可选，默认3000字）
 - `--scene-type`: 场景类型（可选：dialogue/action/description/psychology）
+- `--tension`: 情感张力 (0.0-1.0，可选，默认0.5)
+- `--pov`: 指定视角 (可选，覆盖风格设定)
 
 ### 使用示例
 ```
@@ -29,15 +31,20 @@
 
 ### 第一步：风格配置加载
 1. **验证风格存在**：检查指定的风格是否已学习并保存
-2. **加载风格参数**：读取完整的风格配置文件
-3. **解析风格特征**：理解各维度的风格要求
-4. **设置创作约束**：根据风格参数设定创作规则
+2. **解析复合风格**：如果使用了比例参数（如 `A:0.7, B:0.3`），则分别加载 A 和 B 的特征，并按权重计算最终的创作参数。
+3. **加载风格参数**：读取完整的风格配置文件
+4. **解析风格特征**：理解各维度的风格要求
+5. **设置创作约束**：根据风格参数设定创作规则
 
 ### 第二步：创作准备
 1. **理解创作需求**：分析章节名称和创作要求
-2. **确定场景类型**：识别是对话、动作、描写还是心理场景
-3. **选择适配策略**：根据场景类型调整风格应用强度
-4. **准备风格词库**：激活目标风格的词汇和表达库
+2. **加载全局上下文**：
+    - **读取世界观**：自动关联 `dist/spec/config.json` 或 `memory/world_rules.md` 中的设定。
+    - **读取人物志**：匹配章节中涉及的人物，从 `dist/spec/presets/` 或相关设定文件中加载性格、语言风格和背景。
+    - **检查伏笔与逻辑**：检索 `memory/` 目录下已发生的关键情节，确保不发生逻辑冲突。
+3. **确定场景类型**：识别是对话、动作、描写还是心理场景
+4. **选择适配策略**：根据场景类型调整风格应用强度
+5. **准备风格词库**：激活目标风格的词汇和表达库
 
 ### 第三步：风格化创作
 
@@ -73,7 +80,7 @@
 
 ### 第四步：质量检查和优化
 1. **风格一致性检查**：确保生成内容符合风格要求
-2. **逻辑连贯性验证**：检查情节和逻辑的合理性
+2. **逻辑连贯性验证**：对照全局上下文，检查人物行为是否 OOC（不符合人设），情节是否违反世界观。
 3. **语言流畅性优化**：确保文字自然流畅
 4. **风格强度调节**：根据需要微调风格表现强度
 

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # 更新日志
 
+## [0.21.0] - 2026-01-12
+
+### 🚀 增强功能：创作大师版 (Creative Master)
+
+#### 🧠 深度上下文与逻辑一致性
+- **全局上下文集成**：优化 `/write-styled` 指令，自动检索 `memory/` 下的人物志与世界观设定，确保创作内容不偏离核心人设。
+- **逻辑自检机制**：在生成前增加历史情节对齐环节，减少“吃书”现象。
+
+#### 🎨 风格混响 (Style Mixer)
+- **多风格融合支持**：`/write-styled` 指令现在支持复合风格参数（如 `--style="金庸:0.7, 古龙:0.3"`），允许作者按比例调制独特的混合文风。
+- **动态权重解析**：AI 将根据权重自动提取并融合不同风格的遣词造句特色。
+
+#### 💡 灵感缪斯指令
+- **新增 `/inspire` 指令**：专门解决创作瓶颈。
+  - **灵感发散**：提供 3-5 个具有冲击力的剧情走向（Twists）。
+  - **风格试写**：为每个灵感分支提供 100-200 字的风格化“预演”片段。
+  - **逻辑支撑**：解释每个转折点与已有设定的契合度。
+
+#### 🛠️ 系统优化
+- **跨平台兼容性修复**：全面重构 `package.json` 脚本，使用 Node.js 原生 API 替代 Unix 命令（如 `rm -rf`, `chmod`），确保在 Windows 环境下完美运行。
+- **项目引用一致性**：更新 `bun.lock` 及各插件文档中的项目名称引用为 `novel-writer-style-cn`。
+- **风格专家模型升级**：更新 `style-expert.md`，新增风格融合指导与人设一致性检查模块。
+
 ## [0.20.0] - 2026-01-12
 
 ### 🎨 重大更新：AI风格学习系统

package/dist/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { Command } from '@commander-js/extra-typings';
 import chalk from 'chalk';
 import path from 'path';

package/dist/plugins/manager.js

@@ -1,373 +1,86 @@
 import fs from 'fs-extra';
 import path from 'path';
-import yaml from 'js-yaml';
-import { logger } from '../utils/logger.js';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 插件管理器
+ */
 export class PluginManager {
-    pluginsDir;
-    commandsDirs;
-    expertsDir;
-    constructor(projectRoot) {
-        this.pluginsDir = path.join(projectRoot, 'plugins');
-        this.commandsDirs = {
-            claude: path.join(projectRoot, '.claude', 'commands'),
-            cursor: path.join(projectRoot, '.cursor', 'commands'),
-            gemini: path.join(projectRoot, '.gemini', 'commands'),
-            windsurf: path.join(projectRoot, '.windsurf', 'workflows'),
-            roocode: path.join(projectRoot, '.roo', 'commands')
-        };
-        this.expertsDir = path.join(projectRoot, 'experts');
-    }
-    /**
-     * 扫描并加载所有插件
-     */
-    async loadPlugins() {
-        try {
-            // 确保插件目录存在
-            await fs.ensureDir(this.pluginsDir);
-            // 扫描插件目录
-            const plugins = await this.scanPlugins();
-            if (plugins.length === 0) {
-                logger.info('没有发现插件');
-                return;
-            }
-            logger.info(`发现 ${plugins.length} 个插件`);
-            // 加载每个插件
-            for (const pluginName of plugins) {
-                await this.loadPlugin(pluginName);
-            }
-            logger.success('所有插件加载完成');
-        }
-        catch (error) {
-            logger.error('加载插件失败:', error);
-        }
+    constructor() {
+        this.plugins = new Map();
+        this.loadPlugins();
     }
+
     /**
-     * 扫描插件目录，返回所有插件名称
+     * 加载插件
      */
-    async scanPlugins() {
+    loadPlugins() {
         try {
-            // 检查插件目录是否存在
-            if (!await fs.pathExists(this.pluginsDir)) {
-                return [];
-            }
-            const entries = await fs.promises.readdir(this.pluginsDir, { withFileTypes: true });
-            // 过滤出目录，并且包含config.yaml的
-            const plugins = [];
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    const configPath = path.join(this.pluginsDir, entry.name, 'config.yaml');
-                    if (await fs.pathExists(configPath)) {
-                        plugins.push(entry.name);
-                    }
+            const pluginsDir = path.join(__dirname, '..', '..', 'plugins');
+            if (fs.existsSync(pluginsDir)) {
+                const pluginDirs = fs.readdirSync(pluginsDir, { withFileTypes: true })
+                    .filter(dirent => dirent.isDirectory())
+                    .map(dirent => dirent.name);
+
+                for (const pluginName of pluginDirs) {
+                    this.loadPlugin(pluginName);
                 }
             }
-            return plugins;
-        }
-        catch (error) {
-            logger.error('扫描插件目录失败:', error);
-            return [];
+        } catch (error) {
+            console.warn('Failed to load plugins:', error.message);
         }
     }
+
     /**
      * 加载单个插件
      */
-    async loadPlugin(pluginName) {
-        try {
-            logger.info(`加载插件: ${pluginName}`);
-            // 读取插件配置
-            const configPath = path.join(this.pluginsDir, pluginName, 'config.yaml');
-            const config = await this.loadConfig(configPath);
-            if (!config) {
-                logger.warn(`插件 ${pluginName} 配置无效`);
-                return;
-            }
-            // 检查依赖
-            if (!this.checkDependencies(config)) {
-                logger.warn(`插件 ${pluginName} 依赖不满足`);
-                return;
-            }
-            // 注入命令
-            if (config.commands && config.commands.length > 0) {
-                await this.injectCommands(pluginName, config.commands);
-            }
-            // 注册专家
-            if (config.experts && config.experts.length > 0) {
-                await this.registerExperts(pluginName, config.experts);
-            }
-            logger.success(`插件 ${pluginName} 加载成功`);
-            // 显示安装信息
-            if (config.installation?.message) {
-                console.log(config.installation.message);
-            }
-        }
-        catch (error) {
-            logger.error(`加载插件 ${pluginName} 失败:`, error);
-        }
-    }
-    /**
-     * 读取并解析插件配置
-     */
-    async loadConfig(configPath) {
+    loadPlugin(pluginName) {
         try {
-            const content = await fs.readFile(configPath, 'utf-8');
-            const config = yaml.load(content);
-            // 验证必要字段
-            if (!config.name || !config.version) {
-                return null;
-            }
-            return config;
-        }
-        catch (error) {
-            logger.error(`读取配置文件失败: ${configPath}`, error);
-            return null;
-        }
-    }
-    /**
-     * 检查插件依赖
-     */
-    checkDependencies(config) {
-        if (!config.dependencies) {
-            return true;
-        }
-        // 检查核心版本依赖
-        if (config.dependencies.core) {
-            // 这里简化处理，实际应该比较版本号
-            // 可以使用 semver 库进行版本比较
-            const requiredVersion = config.dependencies.core;
-            logger.debug(`需要核心版本: ${requiredVersion}`);
-            // TODO: 实现版本比较逻辑
-        }
-        return true;
-    }
-    /**
-     * 检测项目支持的 AI 类型
-     */
-    async detectSupportedAIs() {
-        return {
-            claude: await fs.pathExists(this.commandsDirs.claude),
-            cursor: await fs.pathExists(this.commandsDirs.cursor),
-            gemini: await fs.pathExists(this.commandsDirs.gemini),
-            windsurf: await fs.pathExists(this.commandsDirs.windsurf),
-            roocode: await fs.pathExists(this.commandsDirs.roocode)
-        };
-    }
-    /**
-     * 注入插件命令到对应的 AI 目录
-     */
-    async injectCommands(pluginName, commands) {
-        if (!commands)
-            return;
-        // 检测项目支持哪些 AI
-        const supportedAIs = await this.detectSupportedAIs();
-        for (const cmd of commands) {
-            try {
-                // 处理 Markdown 格式（Claude、Cursor、Windsurf）
-                const sourcePath = path.join(this.pluginsDir, pluginName, cmd.file);
-                if (supportedAIs.claude) {
-                    const destPath = path.join(this.commandsDirs.claude, `${cmd.id}.md`);
-                    await fs.ensureDir(this.commandsDirs.claude);
-                    await fs.copy(sourcePath, destPath);
-                    logger.debug(`注入命令到 Claude: /${cmd.id}`);
-                }
-                if (supportedAIs.cursor) {
-                    const destPath = path.join(this.commandsDirs.cursor, `${cmd.id}.md`);
-                    await fs.ensureDir(this.commandsDirs.cursor);
-                    await fs.copy(sourcePath, destPath);
-                    logger.debug(`注入命令到 Cursor: /${cmd.id}`);
-                }
-                if (supportedAIs.windsurf) {
-                    const destPath = path.join(this.commandsDirs.windsurf, `${cmd.id}.md`);
-                    await fs.ensureDir(this.commandsDirs.windsurf);
-                    await fs.copy(sourcePath, destPath);
-                    logger.debug(`注入命令到 Windsurf: /${cmd.id}`);
-                }
-                if (supportedAIs.roocode) {
-                    const destPath = path.join(this.commandsDirs.roocode, `${cmd.id}.md`);
-                    await fs.ensureDir(this.commandsDirs.roocode);
-                    await fs.copy(sourcePath, destPath);
-                    logger.debug(`注入命令到 Roo Code: /${cmd.id}`);
-                }
-                // 处理 TOML 格式（Gemini）
-                if (supportedAIs.gemini) {
-                    // 检查是否有预定义的 TOML 版本
-                    const cmdId = path.basename(cmd.id, path.extname(cmd.id));
-                    const tomlSourcePath = path.join(this.pluginsDir, pluginName, 'commands-gemini', `${cmdId}.toml`);
-                    if (await fs.pathExists(tomlSourcePath)) {
-                        const destPath = path.join(this.commandsDirs.gemini, `${cmdId}.toml`);
-                        await fs.ensureDir(this.commandsDirs.gemini);
-                        await fs.copy(tomlSourcePath, destPath);
-                        logger.debug(`注入命令到 Gemini: /${cmdId} (TOML)`);
-                    }
-                    else {
-                        // 如果没有预定义的 TOML，尝试从 Markdown 转换
-                        try {
-                            const mdContent = await fs.readFile(sourcePath, 'utf-8');
-                            const tomlContent = this.convertMarkdownToToml(mdContent, cmd);
-                            if (tomlContent) {
-                                const destPath = path.join(this.commandsDirs.gemini, `${cmdId}.toml`);
-                                await fs.ensureDir(this.commandsDirs.gemini);
-                                await fs.writeFile(destPath, tomlContent);
-                                logger.debug(`自动转换并注入命令到 Gemini: /${cmdId}`);
-                            }
-                            else {
-                                logger.debug(`插件 ${pluginName} 命令 ${cmdId} 无法转换为 TOML`);
-                            }
-                        }
-                        catch (err) {
-                            logger.debug(`插件 ${pluginName} 命令 ${cmdId} 转换失败: ${err}`);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                logger.error(`注入命令 ${cmd.id} 失败:`, error);
-            }
-        }
-    }
-    /**
-     * 注册插件专家
-     */
-    async registerExperts(pluginName, experts) {
-        if (!experts)
-            return;
-        const pluginExpertsDir = path.join(this.expertsDir, 'plugins', pluginName);
-        await fs.ensureDir(pluginExpertsDir);
-        for (const expert of experts) {
-            try {
-                const sourcePath = path.join(this.pluginsDir, pluginName, expert.file);
-                const destPath = path.join(pluginExpertsDir, `${expert.id}.md`);
-                // 复制专家文件
-                await fs.copy(sourcePath, destPath);
-                logger.debug(`注册专家: ${expert.title} (${expert.id})`);
-            }
-            catch (error) {
-                logger.error(`注册专家 ${expert.id} 失败:`, error);
-            }
+            const pluginPath = path.join(__dirname, '..', '..', 'plugins', pluginName);
+            const packagePath = path.join(pluginPath, 'package.json');
+            
+            if (fs.existsSync(packagePath)) {
+                const packageJson = fs.readJsonSync(packagePath);
+                this.plugins.set(pluginName, {
+                    name: pluginName,
+                    version: packageJson.version || '1.0.0',
+                    description: packageJson.description || '',
+                    path: pluginPath
+                });
+            }
+        } catch (error) {
+            console.warn(`Failed to load plugin ${pluginName}:`, error.message);
         }
     }
+
     /**
-     * 列出所有已安装的插件
+     * 获取所有插件
      */
-    async listPlugins() {
-        const plugins = await this.scanPlugins();
-        const configs = [];
-        for (const pluginName of plugins) {
-            const configPath = path.join(this.pluginsDir, pluginName, 'config.yaml');
-            const config = await this.loadConfig(configPath);
-            if (config) {
-                configs.push(config);
-            }
-        }
-        return configs;
+    getPlugins() {
+        return Array.from(this.plugins.values());
     }
+
     /**
-     * 安装插件（从模板或远程）
+     * 获取插件
      */
-    async installPlugin(pluginName, source) {
-        try {
-            logger.info(`安装插件: ${pluginName}`);
-            // 如果提供了源路径，从源复制
-            if (source) {
-                const destPath = path.join(this.pluginsDir, pluginName);
-                await fs.copy(source, destPath);
-            }
-            else {
-                // TODO: 实现从远程仓库或注册中心安装
-                logger.warn('远程安装功能尚未实现');
-                return;
-            }
-            // 加载新安装的插件
-            await this.loadPlugin(pluginName);
-            logger.success(`插件 ${pluginName} 安装成功`);
-        }
-        catch (error) {
-            logger.error(`安装插件 ${pluginName} 失败:`, error);
-        }
+    getPlugin(name) {
+        return this.plugins.get(name);
     }
+
     /**
-     * 移除插件
+     * 检查插件是否存在
      */
-    async removePlugin(pluginName) {
-        try {
-            logger.info(`移除插件: ${pluginName}`);
-            // 删除插件目录
-            const pluginPath = path.join(this.pluginsDir, pluginName);
-            await fs.remove(pluginPath);
-            // 删除注入的命令（从所有 AI 目录）
-            const supportedAIs = await this.detectSupportedAIs();
-            if (supportedAIs.claude && await fs.pathExists(this.commandsDirs.claude)) {
-                const commandFiles = await fs.promises.readdir(this.commandsDirs.claude);
-                for (const file of commandFiles) {
-                    if (file.startsWith(`plugin-${pluginName}-`)) {
-                        await fs.remove(path.join(this.commandsDirs.claude, file));
-                        logger.debug(`移除命令文件: ${file}`);
-                    }
-                }
-            }
-            // 对其他 AI 目录做同样的清理
-            for (const [aiType, dir] of Object.entries(this.commandsDirs)) {
-                if (aiType !== 'claude' && await fs.pathExists(dir)) {
-                    const commandFiles = await fs.promises.readdir(dir);
-                    for (const file of commandFiles) {
-                        if (file.startsWith(`plugin-${pluginName}-`)) {
-                            await fs.remove(path.join(dir, file));
-                            logger.debug(`移除 ${aiType} 命令文件: ${file}`);
-                        }
-                    }
-                }
-            }
-            // 删除注册的专家
-            const pluginExpertsDir = path.join(this.expertsDir, 'plugins', pluginName);
-            if (await fs.pathExists(pluginExpertsDir)) {
-                await fs.remove(pluginExpertsDir);
-                logger.debug(`移除专家目录: ${pluginExpertsDir}`);
-            }
-            logger.success(`插件 ${pluginName} 移除成功`);
-        }
-        catch (error) {
-            logger.error(`移除插件 ${pluginName} 失败:`, error);
-        }
+    hasPlugin(name) {
+        return this.plugins.has(name);
     }
-    /**
-     * 将 Markdown 命令转换为 TOML 格式
-     */
-    convertMarkdownToToml(mdContent, cmd) {
-        try {
-            // 提取 frontmatter
-            const frontmatterMatch = mdContent.match(/^---\n([\s\S]*?)\n---/);
-            let description = cmd.description || '';
-            if (frontmatterMatch) {
-                const yamlContent = frontmatterMatch[1];
-                const descMatch = yamlContent.match(/description:\s*(.+)/);
-                if (descMatch) {
-                    description = descMatch[1].trim().replace(/^['"]|['"]$/g, '');
-                }
-            }
-            // 提取内容（去除 frontmatter）
-            const content = mdContent.replace(/^---\n[\s\S]*?\n---\n/, '');
-            // 构建 TOML 内容
-            const tomlContent = `description = "${description}"
-
-prompt = """
-${content}
 
-用户输入：{{args}}
-"""`;
-            return tomlContent;
-        }
-        catch (error) {
-            return null;
-        }
-    }
     /**
-     * 更新插件
+     * 列出所有插件
      */
-    async updatePlugin(pluginName, source) {
-        logger.info(`更新插件: ${pluginName}`);
-        // 先移除旧版本
-        await this.removePlugin(pluginName);
-        // 安装新版本
-        await this.installPlugin(pluginName, source);
+    listPlugins() {
+        return this.getPlugins();
     }
-}
-//# sourceMappingURL=manager.js.map
+}