@cloud411716/fancy-webnovel 1.0.45 → 2.2.0

package/plugins/fancy-analyze/index.js

@@ -0,0 +1,973 @@
+/**
+ * fancy-analyze plugin entry
+ *
+ * 触发命令: /fancy-analyze [书名]
+ *
+ * 流程：
+ *   1. 检查 .fancy-deployed 存在（项目已初始化）
+ *   2. 取书名：参数 / 弹窗
+ *   3. 在 参考资料/ 下查找匹配的源文件
+ *   4. 调用 llm_wiki API 创建项目
+ *   5. 拷贝 schema-analyze.md → 对标/schema.md
+ *   6. 执行 split_source.js 拆书，结果存到 对标/raw/sources/<书名>/
+ *   7. 调用 llm_wiki sources/ingest 接口
+ *   8. 通知完成
+ *
+ * 不依赖 phase：这个 skill 可以独立于整条流水线使用
+ * （用户在写正文之前、中途、之后都可以调用来分析参考爆款）
+ */
+import { existsSync, statSync, readdirSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, unlinkSync, renameSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { askUserQuestion, spawnScript } from '#infra';
+import { notify, llmFollowup } from '#infra';
+import { describeFetchError, llmWikiError, readJsonSafe } from '#llm-wiki';
+import { readDeployedState, DEPLOYED_STATUS } from '#deployed-state';
+import { analyze } from './templates.js';
+import {
+  scanSummaryProgress,
+  dirsToDispatch,
+  listTechDirs,
+} from './summary-progress.js';
+import { normalizeCommandInput, matchSubcommand } from './command-input.js';
+
+export const inject = ['commands', 'userQuestions'];
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SPLIT_SCRIPT = join(__dirname, 'scripts', 'split_source.js');
+const SCHEMA_SOURCE = join(__dirname, 'schema-analyze.md');
+
+/** resummary 备份旧总结文件的目录（放在 对标/ 下，不在 wiki 树里，免得被当成技法目录）。 */
+const SUMMARY_BACKUP_DIRNAME = '.summary-backup';
+
+/**
+ * 把时间戳格式化成 "20261026-1930" 这样的目录名。
+ * @param {number} ts - 毫秒时间戳
+ * @returns {string}
+ */
+function backupStamp(ts) {
+  const d = new Date(ts);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+function getProjectRoot(session) {
+  // 不能回退到 process.cwd()：那是宿主进程的工作目录，不是用户项目目录。
+  // 宿主若恰好在某个含 .fancy-deployed 的目录里启动，会对错误的项目执行部署与写盘。
+  // 此时返回 null，由调用方给出明确报错。
+  const cwd = session.header?.cwd;
+  return cwd || null;
+}
+
+/**
+ * 读取 .fancy-deployed 配置
+ *
+ * 必须区分「读不到」和「读到了但坏了」：
+ * 之前一律返回 null，于是 .fancy-deployed 是坏 JSON 时也报
+ * "尚未初始化，请先运行 /fancy-bootstrap" —— 而 bootstrap 在这个
+ * 状态下多半也跑不通（文件已存在），用户会被这条错误指引带偏。
+ *
+ * @returns {{config: object|null, error: 'missing'|'corrupt'|'no_phase'|null, message?: string}}
+ */
+function readDeployedConfig(projectRoot) {
+  const state = readDeployedState(projectRoot);
+  if (state.status === DEPLOYED_STATUS.OK) {
+    return { config: state.config, error: null };
+  }
+  if (state.status === DEPLOYED_STATUS.MISSING) {
+    return { config: null, error: 'missing' };
+  }
+  return { config: null, error: 'corrupt', message: state.error || state.status };
+}
+
+/**
+ * 更新 .fancy-deployed 中的指定字段
+ *
+ * 必须原子写：直接 writeFileSync 在写到一半时断电/中断，
+ * 会把 .fancy-deployed 截断成半个 JSON —— 而这个文件是所有插件
+ * 的项目状态源，坏掉之后整个项目都进不去。
+ * 仓库里 fancy-topic / fancy-scan 都用 tmp + rename 的写法。
+ */
+function updateDeployedField(projectRoot, key, value) {
+  const deployedPath = join(projectRoot, '.fancy-deployed');
+  const { config } = readDeployedConfig(projectRoot);
+  if (!config) return false;
+  config[key] = value;
+  const tmpPath = join(dirname(deployedPath), `.${Date.now()}-${process.pid}.tmp`);
+  try {
+    writeFileSync(tmpPath, JSON.stringify(config, null, 2), 'utf-8');
+    renameSync(tmpPath, deployedPath);
+    return true;
+  } catch {
+    try { unlinkSync(tmpPath); } catch { /* 清理失败无所谓 */ }
+    return false;
+  }
+}
+
+/**
+ * 在 handler 里取 .fancy-deployed 配置。
+ *
+ * 三条路径（fix / status / 普通）都要用，所以收成一个入口，
+ * 免得"损坏 vs 未初始化"在某个分支上又被压成同一种错误。
+ *
+ * @returns {{config: object|null, errorText: string|null}}
+ */
+function loadDeployedConfig(projectRoot) {
+  const { config, error, message } = readDeployedConfig(projectRoot);
+  if (error === 'missing') {
+    return { config: null, errorText: analyze.notify({ type: 'not_initialized' }) };
+  }
+  if (error) {
+    return {
+      config: null,
+      errorText: analyze.notify({ type: 'deployed_unreadable', err: message }),
+    };
+  }
+  return { config, errorText: null };
+}
+
+/**
+ * 调用 llm_wiki API
+ * @param {string} baseUrl - llm_wiki_url（已去除末尾斜杠）
+ * @param {string} token - llm_wiki_token
+ * @param {string} path - API 路径
+ * @param {string} method - HTTP 方法
+ * @param {object} body - 请求体
+ * @param {number} [timeoutMs] - 超时（默认 30s）
+ */
+async function callLlmWikiApi(baseUrl, token, path, method = 'POST', body = null, timeoutMs = 30000) {
+  const url = `${baseUrl}${path}`;
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${token}`,
+  };
+  const options = {
+    method,
+    headers,
+  };
+  if (body) {
+    options.body = JSON.stringify(body);
+  }
+  // 必须有超时：fetch 默认永不超时，llm_wiki 挂住时命令会永远卡着，
+  // 用户既看不到提示也拿不回终端。
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    // 响应体可能不是 JSON（例如网关返回 HTML 错误页）——
+    // readJsonSafe 返回 null 而不是抛 SyntaxError，把真正的原因盖掉。
+    const data = await readJsonSafe(response);
+    return { status: response.status, data };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * 转义正则元字符（用于把用户/文件里的字符串安全地拼进正则）。
+ */
+function escapeRegExp(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * 查询 ingest 状态
+ * @param {string} baseUrl - llm_wiki_url
+ * @param {string} token - llm_wiki_token
+ * @param {string} projectId - reference_id
+ */
+async function queryIngestStatus(baseUrl, token, projectId) {
+  return callLlmWikiApi(baseUrl, token, `/projects/${projectId}/ingest/querystatus`, 'GET', null);
+}
+
+/**
+ * 在 参考资料/ 下查找匹配的源文件
+ *
+ * 匹配规则：
+ * - 接受文件名（不带后缀）或完整文件名（带后缀）
+ * - 忽略后缀比较（.txt / .md / .epub / .docx 都算同名的"诡秘之主"）
+ * - 不区分大小写
+ *
+ * 支持目录结构：
+ *   参考资料/<书名>.txt           （文件）
+ *
+ * 返回：
+ *   { path }                       找到唯一匹配
+ *   { error: 'dir_missing' }      参考资料/ 不存在
+ *   { error: 'not_found', matches: [...] }  无匹配，列出目录下所有条目供用户参考
+ *   { error: 'ambiguous', matches: [...] } 多个匹配
+ */
+function findSourceFile(refDir, bookName) {
+  if (!existsSync(refDir)) {
+    return { error: 'dir_missing' };
+  }
+
+  const stripExt = (s) => s.toLowerCase().replace(/\.[^./\\]+$/g, '');
+  // 只取文件名部分，忽略用户可能输入的路径前缀
+  const targetBase = bookName.trim().split(/[\\/]/).pop();
+  const target = stripExt(targetBase);
+
+  const stat = statSync(refDir);
+  const entries = stat.isDirectory()
+    ? readdirSync(refDir)
+    : [];
+
+  // 情况：参考资料/<书名>.txt（文件）
+  const directMatches = [];
+  for (const name of entries) {
+    if (stripExt(name) === target) {
+      const full = join(refDir, name);
+      const st = statSync(full);
+      if (st.isFile()) {
+        directMatches.push({ path: full, kind: 'file' });
+      }
+    }
+  }
+
+  if (directMatches.length === 1) {
+    return { path: directMatches[0].path };
+  }
+  if (directMatches.length > 1) {
+    return { error: 'ambiguous', matches: directMatches.map(m => m.path) };
+  }
+
+  // 没有匹配 → 列出目录下所有可识别的条目
+  const allCandidates = entries
+    .map(name => ({ name, stripped: stripExt(name) }))
+    .filter(e => e.name !== '.DS_Store' && e.name !== 'Thumbs.db');
+  return { error: 'not_found', matches: allCandidates.map(c => c.name) };
+}
+
+/**
+ * 拷贝 schema 文件到目标目录
+ */
+function copySchemaFile(targetDir) {
+  const targetPath = join(targetDir, 'schema.md');
+  mkdirSync(targetDir, { recursive: true });
+  copyFileSync(SCHEMA_SOURCE, targetPath);
+  return targetPath;
+}
+
+export async function apply(ctx) {
+  ctx.commands.register({
+    name: 'fancy-analyze',
+    description: '🔍 拆解爆款小说（参考对标） ( usage: /fancy-analyze [书名] | status | fix | summary | summary-status | resummary [技法名] )',
+    input: {
+      hint: '.',
+    },
+    handler: async (invocation) => {
+      const session = invocation.agent.session;
+      const { signal } = invocation;
+
+      const projectRoot = getProjectRoot(session);
+      if (!projectRoot) {
+        return notify(session, 'error', analyze.notify({
+          type: 'no_project_root',
+          err: '会话未提供 cwd'
+        }));
+      }
+
+      // 1. 检查 .fancy-deployed
+      if (!existsSync(join(projectRoot, '.fancy-deployed'))) {
+        return notify(session, 'error', analyze.notify({ type: 'not_initialized' }));
+      }
+
+      // 2. 解析命令类型
+      // 2. 解析命令类型
+      //
+      // 输入要先**剥掉不可见字符**再判断。
+      //
+      // ## 为什么
+      //
+      // 实测用户输入过 `summary-status\u200bsummary`（零宽空格 U+200B 粘在中间）。
+      // 旧代码直接 `lowerInput === 'summary-status'` 精确比较，于是这条命令
+      // **既不是** summary-status **也不是** summary —— 它掉进了"普通模式"
+      // （按书名拆书），而拆书会调 llm_wiki 的 sources/ingest 接口，
+      // 那条路**有破坏性**。
+      //
+      // 子命令判断失败时掉进一个有破坏性的分支，是很糟的默认行为。
+      // 所以：
+      //   1. 剥掉不可见字符（零宽空格/零宽连接符/BOM/不换行空格…）；
+      //   2. 用**前缀匹配**认子命令 —— 用户手滑多打了几个字，
+      //      意图明显是那个子命令，不该被当成书名去拆书。
+      const rawInput = normalizeCommandInput(invocation.rawInput || '');
+      const lowerInput = rawInput.toLowerCase();
+      const sub = matchSubcommand(lowerInput);
+      const isStatus = sub === 'status';
+      const isFix = sub === 'fix';
+      const isSummary = sub === 'summary';
+      const isSummaryStatus = sub === 'summary-status';
+      const isResummary = sub === 'resummary';
+      const resummaryTarget = isResummary
+        ? rawInput.slice('resummary'.length).trim()
+        : '';
+
+      // 2.1 fix 模式：重新 ingest 缺失的文件
+      if (isFix) {
+        const { config: deployedConfig, errorText: configError } = loadDeployedConfig(projectRoot);
+        if (configError) {
+          return notify(session, 'error', configError);
+        }
+
+        const llmWikiUrl = (deployedConfig.llm_wiki_url || '').replace(/\/$/, '');
+        const llmWikiToken = deployedConfig.llm_wiki_token || '';
+        const referenceId = deployedConfig.reference_id || '';
+
+        if (!llmWikiUrl || !llmWikiToken) {
+          return notify(session, 'error', analyze.notify({ type: 'llm_wiki_not_configured' }));
+        }
+
+        if (!referenceId) {
+          return notify(session, 'error', analyze.notify({ type: 'no_reference_id' }));
+        }
+
+        // 读取 .retry 文件
+        const retryFilePath = join(projectRoot, '.retry');
+        if (!existsSync(retryFilePath)) {
+          return notify(session, 'error', `没有找到 .retry 文件。
+1. 如果已执行过 fancy-analyze status 子命令则代表已成功提取，可以继续执行 fancy-analyze summary
+2. 如果未执行过 fancy-analyze status 子命令请先执行该命令`);
+        }
+
+        let retryData;
+        try {
+          retryData = JSON.parse(readFileSync(retryFilePath, 'utf-8'));
+        } catch {
+          return notify(session, 'error', '.retry 文件格式错误');
+        }
+
+        if (!retryData || !Array.isArray(retryData.items) || retryData.items.length === 0) {
+          return notify(session, 'success', '没有需要重试的项目');
+        }
+
+        const rawSourcesDir = join(projectRoot, '对标', 'raw', 'sources');
+        const results = [];
+        const errors = [];
+
+        for (const item of retryData.items) {
+          const { bookName, chapter } = item;
+          // 定位文件：书名/ 目录下查找文件名包含"第X章"的文件
+          const bookDir = join(rawSourcesDir, bookName);
+          if (!existsSync(bookDir)) {
+            errors.push(`未找到目录：${bookName}`);
+            continue;
+          }
+
+          let matchedFile = null;
+          try {
+            const files = readdirSync(bookDir);
+            // 查找文件名中包含"第X章"的文件（如：第8章-心好痛.txt）
+            // chapter 来自 .retry（status 生成的"第N章"），但仍要转义：
+            // 直接拼进正则的话，一旦内容里出现正则元字符就会抛 SyntaxError，
+            // 而且 "." 未转义会让"第1章"匹配上"第1章X"这种文件名。
+            const pattern = new RegExp(`${escapeRegExp(chapter)}.*\\.txt$`);
+            matchedFile = files.find(f => pattern.test(f));
+            if (!matchedFile) {
+              errors.push(`未找到文件：${bookName} 下包含 ${chapter} 的文件`);
+              continue;
+            }
+
+            // 清除 ingest-cache 中对应条目的 hash
+            const ingestCachePath = join(projectRoot, '对标', '.llm-wiki', 'ingest-cache.json');
+            if (existsSync(ingestCachePath)) {
+              try {
+                const cacheContent = readFileSync(ingestCachePath, 'utf-8');
+                const cacheData = JSON.parse(cacheContent);
+                const cacheKey = `${bookName}/${matchedFile}`;
+                if (cacheData.entries && cacheData.entries[cacheKey]) {
+                  cacheData.entries[cacheKey].hash = '';
+                  writeFileSync(ingestCachePath, JSON.stringify(cacheData, null, 2), 'utf-8');
+                }
+              } catch {
+                // 忽略缓存更新错误
+              }
+            }
+
+            const filePath = `raw/sources/${bookName}/${matchedFile}`;
+            // 必须检查返回：ingest 返回 4xx/5xx 时 llm_wiki 根本没收到文件，
+            // 之前这里不检查，命令照报"## 重新 ingest 成功"（实测：两个 POST
+            // 都返回 500，用户看到的仍是"成功"）。
+            const ingestResult = await callLlmWikiApi(
+              llmWikiUrl,
+              llmWikiToken,
+              `/projects/${referenceId}/sources/ingest`,
+              'POST',
+              { paths: [filePath] }
+            );
+            const apiErr = llmWikiError(ingestResult);
+            if (apiErr) {
+              errors.push(`${bookName}/${matchedFile} - ${apiErr}`);
+              continue;
+            }
+            results.push(`${bookName}/${matchedFile}`);
+          } catch (err) {
+            errors.push(`${bookName}/${chapter} - ${describeFetchError(err)}`);
+          }
+        }
+
+        let message = '';
+        if (results.length > 0) {
+          message += '## 重新 ingest 成功\n' + results.join('\n');
+        }
+        if (errors.length > 0) {
+          if (results.length > 0) {
+            message += '\n';
+          }
+          message += '## 错误\n' + errors.join('\n');
+        }
+
+        // 全部失败时，标题要单独一行 —— 之前 "重新 ingest 失败：" 直接
+        // 粘在 "## 错误" 前面，渲染出来是一行乱糟糟的文本。
+        const headline = (errors.length > 0 && results.length === 0)
+          ? '重新 ingest 失败：\n\n'
+          : '';
+        const finalMessage = headline + message + '\n\n请稍后执行 /fancy-analyze status 查看结果，如果仍有缺失需再次执行 /fancy-analyze fix';
+        return notify(session, results.length > 0 ? 'success' : 'error', finalMessage);
+      }
+
+      // 2.2 status 模式
+      if (isStatus) {
+        const { config: deployedConfig, errorText: configError } = loadDeployedConfig(projectRoot);
+        if (configError) {
+          return notify(session, 'error', configError);
+        }
+
+        const llmWikiUrl = (deployedConfig.llm_wiki_url || '').replace(/\/$/, '');
+        const llmWikiToken = deployedConfig.llm_wiki_token || '';
+        const referenceId = deployedConfig.reference_id || '';
+
+        if (!llmWikiUrl || !llmWikiToken) {
+          return notify(session, 'error', analyze.notify({ type: 'llm_wiki_not_configured' }));
+        }
+
+        if (!referenceId) {
+          return notify(session, 'error', analyze.notify({ type: 'no_reference_id' }));
+        }
+
+        // 检查来源目录下的文件，从"### 列表"表格中获取【有/无】信息
+        // 同时读取"来源"和"来源摘要"两个目录
+        // 映射格式：{ "书名": { "第X章": { "技法名": true/false, ... }, ... } }
+        const bookChapterTechHas = {};
+        // 记录缺少列表的章节
+        const missingListReports = [];
+
+        const sourceDirs = ['来源', '来源摘要'];
+        for (const sourceDir of sourceDirs) {
+          const duiBiaoWikiDir = join(projectRoot, '对标', 'wiki', sourceDir);
+          if (!existsSync(duiBiaoWikiDir)) continue;
+
+          try {
+            const sourceFiles = readdirSync(duiBiaoWikiDir);
+            for (const file of sourceFiles) {
+              if (!file.endsWith('.md')) continue;
+              // 提取书名和第X章（如：全球高武-第10章-气血检查.md → 书名:全球高武, 第X章:第10章）
+              // 格式：书名-第X章-xxx.md 或 书名-技法名-第X章.md
+              const fullMatch = file.match(/^(.+?)-(第\d+章)-/);
+              if (!fullMatch) continue;
+              const bookName = fullMatch[1];
+              const chapterKey = fullMatch[2];
+
+              if (!bookChapterTechHas[bookName]) {
+                bookChapterTechHas[bookName] = {};
+              }
+
+              const content = readFileSync(join(duiBiaoWikiDir, file), 'utf-8');
+
+              // 查找"### 列表"三级标题的位置
+              const listHeadingIndex = content.indexOf('### 列表');
+              if (listHeadingIndex === -1) {
+                // 记录缺少列表的章节
+                missingListReports.push(`${bookName}${chapterKey}的列表未找到`);
+                continue;
+              }
+
+              // 从"### 列表"之后提取表格内容（到下一个三级标题之前）
+              const afterList = content.substring(listHeadingIndex);
+              const nextHeadingMatch = afterList.match(/\n#{1,3}\s+\S/);
+              const tableEndIndex = nextHeadingMatch
+                ? afterList.indexOf(nextHeadingMatch[0])
+                : afterList.length;
+              const tableContent = afterList.substring(0, tableEndIndex);
+
+              // 解析 markdown 表格
+              const tableLines = tableContent.split('\n');
+              const techHas = {}; // { "世界观构建": true, "伏笔回收": false, ... }
+
+              for (const line of tableLines) {
+                // 匹配表格行：| 技法名 | 有/无 |
+                const rowMatch = line.match(/^\|\s*(.+?)\s*\|\s*(有|无)\s*\|/);
+                if (rowMatch) {
+                  const techName = rowMatch[1].trim();
+                  const hasValue = rowMatch[2] === '有';
+                  techHas[techName] = hasValue;
+                }
+              }
+
+              bookChapterTechHas[bookName][chapterKey] = techHas;
+            }
+          } catch {
+            // 忽略读取错误
+          }
+        }
+
+        // 检查各技法目录下是否有对应的文件
+        // 映射格式：{ "书名": { "技法名": ["第X章", "第Y章", ...], ... }, ... }
+        const bookTechChapters = {};
+
+        const duiBiaoWikiRoot = join(projectRoot, '对标', 'wiki');
+        if (existsSync(duiBiaoWikiRoot)) {
+          const allDirs = readdirSync(duiBiaoWikiRoot);
+          for (const dir of allDirs) {
+            // 跳过来源相关目录
+            if (dir === '来源' || dir === '来源摘要') continue;
+
+            const dirPath = join(duiBiaoWikiRoot, dir);
+            if (!statSync(dirPath).isDirectory()) continue;
+
+            const files = readdirSync(dirPath);
+            for (const file of files) {
+              if (!file.endsWith('.md')) continue;
+              // 提取书名和第X章（如：全球高武-节奏韵律-第10章.md → 书名:全球高武, 第X章:第10章）
+              const fullMatch = file.match(/^(.+?)-.+?-(第\d+章)/);
+              if (fullMatch) {
+                const bookName = fullMatch[1];
+                const chapterKey = fullMatch[2];
+                const techName = dir; // 目录名就是技法名
+
+                if (!bookTechChapters[bookName]) {
+                  bookTechChapters[bookName] = {};
+                }
+                if (!bookTechChapters[bookName][techName]) {
+                  bookTechChapters[bookName][techName] = [];
+                }
+                bookTechChapters[bookName][techName].push(chapterKey);
+              }
+            }
+          }
+        }
+
+        // 比对结果：找出"标记为有、但技法目录里没有对应文件"的章节。
+        // 之前同一段逻辑算了两遍（一次出报告、一次出 .retry），
+        // 两份循环还得保持一致，改一处漏一处就会让报告和 .retry 对不上。
+        const missingReports = [];
+        const retryItems = [];
+        for (const [bookName, chapterTechHas] of Object.entries(bookChapterTechHas)) {
+          for (const [chapter, techHas] of Object.entries(chapterTechHas)) {
+            const missingTechs = [];
+            for (const [tech, hasValue] of Object.entries(techHas)) {
+              // 只检查"有"的技法
+              if (hasValue !== true) continue;
+              // 检查该技法目录下是否有该章节的文件
+              const hasFile = bookTechChapters[bookName]?.[tech]?.includes(chapter);
+              if (!hasFile) {
+                missingTechs.push(tech);
+              }
+            }
+            if (missingTechs.length > 0) {
+              missingReports.push(`${bookName}${chapter}的ingest有缺失，缺失的为${missingTechs.join('、')}`);
+              retryItems.push({ bookName, chapter });
+            }
+          }
+        }
+        // 添加缺少列表的章节到 retry
+        for (const report of missingListReports) {
+          const match = report.match(/^(.+?)(第\d+章)的列表未找到/);
+          if (match) {
+            const bookName = match[1];
+            const chapter = match[2];
+            const exists = retryItems.some(item => item.bookName === bookName && item.chapter === chapter);
+            if (!exists) {
+              retryItems.push({ bookName, chapter });
+            }
+          }
+        }
+        // 根据当前检查结果覆盖 .retry 文件
+        // 写失败必须说出来：写不进去的话，后面 /fancy-analyze fix 只会报
+        // "没有找到 .retry 文件"，用户完全不知道真正的失败原因在这里。
+        let retryWriteError = null;
+        try {
+          if (retryItems.length > 0) {
+            writeFileSync(join(projectRoot, '.retry'), JSON.stringify({ items: retryItems }, null, 2), 'utf-8');
+          } else {
+            // 没有缺失项时删除 .retry 文件
+            const retryFilePath = join(projectRoot, '.retry');
+            if (existsSync(retryFilePath)) {
+              unlinkSync(retryFilePath);
+            }
+          }
+        } catch (err) {
+          retryWriteError = err instanceof Error ? err.message : String(err);
+        }
+
+        try {
+          const result = await queryIngestStatus(llmWikiUrl, llmWikiToken, referenceId);
+
+          // 既要查 data.ok，也要查 HTTP 状态码 —— llm_wiki 返回 502/401 时
+          // data 里可能没有 error 字段，只判 ok 会漏。
+          const queryErr = llmWikiError(result);
+          if (queryErr || !result.data || !result.data.ok) {
+            return notify(session, 'error', analyze.notify({
+              type: 'status_query_failed',
+              err: queryErr || result.data?.error || '查询失败'
+            }));
+          }
+
+          const missingFiles = result.data.missingFiles || [];
+          const queue = result.data.queue || {};
+
+          let message = '';
+          if (retryWriteError) {
+            message += `\n\n❌ 写入 .retry 文件失败：${retryWriteError}` +
+              '\n缺失清单没能保存，/fancy-analyze fix 将无法工作。';
+          }
+          if (missingReports.length > 0) {
+            message += '\n\n## 缺失检测\n' + missingReports.join('\n');
+          }
+          if (missingListReports.length > 0) {
+            message += '\n\n## 列表未找到\n' + missingListReports.join('\n');
+          }
+
+          return notify(session, 'success', analyze.notify({
+            type: 'status_result',
+            missingFiles,
+            queue,
+            extraMessage: message,
+          }));
+        } catch (err) {
+          const errMsg = describeFetchError(err);
+          return notify(session, 'error', analyze.notify({
+            type: 'status_query_failed',
+            err: errMsg
+          }));
+        }
+      }
+
+      // 2.3 summary-status：查技法总结进度（纯本地，零网络、零 LLM）
+      //
+      // 这一支刻意不碰 llm_wiki：summary 的进度是**本地文件系统事实**
+      // （总结文件头部的「已总结章节」清单），跟 llm_wiki 的 ingest 队列
+      // 是两回事 —— ingest 队列是"拆解"进度，summary-status 是"总结"进度。
+      if (isSummaryStatus) {
+        const wikiRoot = join(projectRoot, '对标', 'wiki');
+        if (!existsSync(wikiRoot)) {
+          return notify(session, 'error', '❌ "对标/wiki" 目录不存在');
+        }
+        const progress = scanSummaryProgress(wikiRoot);
+        return notify(session, 'success', analyze.notify({
+          type: 'summary_status',
+          summary: progress,
+        }));
+      }
+
+      // 2.4 resummary [技法名]：强制重新总结
+      //
+      // 语义：把指定技法（或全部技法）的总结文件**移入备份目录**，
+      // 于是头部���「已总结章节」清单一起没了 —— 下次派发时所有源章节
+      // 都会被当成"未总结"，模型从头再写一遍。
+      //
+      // 为什么不"就地清空头部"：那样旧技法条目还留在文件里，模型会把
+      // 新写的和旧的混在一起，文件越滚越胖。移走是最干脆的"重来"。
+      // 备份而不是删除：旧总结可能还有参考价值。
+      if (isResummary) {
+        const wikiRoot = join(projectRoot, '对标', 'wiki');
+        if (!existsSync(wikiRoot)) {
+          return notify(session, 'error', '❌ "对标/wiki" 目录不存在');
+        }
+
+        const allDirs = listTechDirs(wikiRoot);
+        const targets = resummaryTarget
+          ? allDirs.filter((name) => name === resummaryTarget)
+          : allDirs;
+
+        if (resummaryTarget && targets.length === 0) {
+          const known = allDirs.join('、');
+          return notify(session, 'error',
+            `❌ 没有名为「${resummaryTarget}」的技法目录` +
+            (known ? `。可用：${known}` : '（对标/wiki 下还没有技法目录）'));
+        }
+
+        const stamp = backupStamp(Date.now());
+        const backupDir = join(projectRoot, '对标', SUMMARY_BACKUP_DIRNAME, stamp);
+        const reset = [];
+
+        for (const name of targets) {
+          const summaryPath = join(wikiRoot, name, `${name}-总结.md`);
+          if (!existsSync(summaryPath)) continue;
+          try {
+            mkdirSync(backupDir, { recursive: true });
+            const backupPath = join(backupDir, `${name}-总结.md`);
+            renameSync(summaryPath, backupPath);
+            reset.push({ name, backup: backupPath });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return notify(session, 'error', `❌ 重置「${name}」失败：${msg}`);
+          }
+        }
+
+        const progress = scanSummaryProgress(wikiRoot);
+        // 重置完，头部清单没了 → 所有源章节都算"未总结"。
+        // 提示词同样只给目录：章节名让模型自己去目录里找。
+        const tasks = dirsToDispatch(progress).map((p) => ({
+          name: p.name,
+          sourceCount: p.sourceCount,
+          pendingCount: p.pendingFiles.length,
+        }));
+        const remainingChapters = tasks.reduce((n, t) => n + t.pendingCount, 0);
+
+        let dispatched = 0;
+        if (tasks.length > 0) {
+          const prompt = analyze.generateSummarySystemPrompt({ tasks, remainingChapters });
+          const follow = await llmFollowup(invocation, prompt);
+          if (!follow || follow.ok !== true) {
+            return notify(session, 'error',
+              '❌ 重置完成，但提示词投递失败：' + ((follow && follow.error) || '未知错误') +
+              '\n旧总结已备份，用 /fancy-analyze summary-status 确认当前状态');
+          }
+          dispatched = tasks.length;
+        }
+
+        return notify(session, 'success', analyze.notify({
+          type: 'summary_reset',
+          summary: { reset, dispatched: tasks.map((t) => t.name), remainingChapters },
+        }));
+      }
+
+      // 2.5 summary 模式：总结各技法目录（只给目录，章节让模型自己找）
+      //
+      // **只派发"还有章节没总结"的目录**：
+      // 头部「已总结章节」清单是唯一事实源，插件据此算出每个目录还差哪些章节，
+      // 只把这部分交给模型。这样反复执行 summary 不会重复总结已有章节。
+      //
+      // 报的是"已派发"而不是"已完成"：
+      // llmFollowup 只代表提示词入队（lib/infra.js:329-332），真正的写作是
+      // 模型在后续 agent loop 里异步完成的。之前这里直接报"✅ 技法总结完成"，
+      // 模型一个字都还没写 —— 那是假成功。
+      if (isSummary) {
+        try {
+          const wikiRoot = join(projectRoot, '对标', 'wiki');
+          if (!existsSync(wikiRoot)) {
+            return notify(session, 'error', '❌ "对标/wiki" 目录不存在');
+          }
+
+          const progress = scanSummaryProgress(wikiRoot);
+          const toDispatch = dirsToDispatch(progress);
+
+          const skippedDone = progress.done.map((p) => p.name);
+          const skippedNoInput = progress.noInput.map((p) => p.name);
+
+          if (toDispatch.length === 0) {
+            return notify(session, 'success', analyze.notify({
+              type: 'summary_nothing_to_do',
+              summary: { done: skippedDone, skippedNoInput },
+            }));
+          }
+
+          // 提示词**只给目录**，不给章节名 —— 一本长篇可能几千章，
+          // 把章节名列进提示词就是几十 K token 的静态开销（实测 3200 章 → 71 KB）。
+          // 每个目录里写清楚"怎么判断哪些章节还没总结"，模型自己去目录里找。
+          const tasks = toDispatch.map((p) => ({
+            name: p.name,
+            sourceCount: p.sourceCount,
+            pendingCount: p.pendingFiles.length,
+          }));
+          const remainingChapters = toDispatch.reduce((n, p) => n + p.pendingFiles.length, 0);
+
+          // 生成提示词
+          const prompt = analyze.generateSummarySystemPrompt({ tasks, remainingChapters });
+
+          // 调用 LLM 进行总结
+          const follow = await llmFollowup(invocation, prompt);
+          // llmFollowup 内部已捕获异常并返回 { ok, error }，必须检查返回值，
+          // 否则投递失败也会报"技法总结完成"
+          if (!follow || follow.ok !== true) {
+            return notify(session, 'error', '❌ 提示词投递失败：' + ((follow && follow.error) || '未知错误'));
+          }
+
+          return notify(session, 'success', analyze.notify({
+            type: 'summary_dispatched',
+            summary: { tasks, skippedDone, skippedNoInput, remainingChapters },
+          }));
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return notify(session, 'error', '❌ summary 执行失败：' + errMsg);
+        }
+      }
+
+      // 2.6 普通模式：取书名
+      let bookName = rawInput;
+
+      if (!bookName) {
+        // 弹窗
+        const askedresult = await askUserQuestion(ctx, invocation, [analyze.askBookName()]);
+        if (!askedresult.ok) {
+          return notify(session, 'error', analyze.notify({
+            type: askedresult.failure.type,
+            err: askedresult.failure.message
+          }));
+        }
+        const result = askedresult.answer;
+        if (!result?.answers?.[0]) {
+          return notify(session, 'error', analyze.notify({ type: 'cancelled' }));
+        }
+        bookName = (result.answers[0].custom || result.answers[0].selected?.[0] || '').trim();
+        if (!bookName) {
+          return notify(session, 'error', analyze.notify({ type: 'cancelled' }));
+        }
+      }
+
+      // 2.6.1 清理书名（去除后缀，用于目录和路径）
+      // 注意：此时 bookNameClean 还未定义，下面会在 sourcePath 获取后重新计算
+
+      // 3. 在 参考资料/ 下查找匹配的源文件（忽略后缀）
+      const refDir = join(projectRoot, '参考资料');
+      const lookup = findSourceFile(refDir, bookName);
+      if (lookup.error === 'dir_missing') {
+        // 必须传 refDir 和 bookName —— 模板的"参考资料/ 目录不存在：${refDir}"
+        // 和"手动下载《${bookName}》"要用它们；之前只传了 projectRoot，
+        // 消息里路径和书名都是空的。
+        return notify(session, 'error', analyze.notify({
+          type: 'source_dir_missing',
+          bookName,
+          refDir,
+          projectRoot,
+        }));
+      }
+      if (lookup.error === 'not_found') {
+        return notify(session, 'error', analyze.notify({
+          type: 'source_missing',
+          bookName,
+          projectRoot,
+          refDir,
+        }));
+      }
+      if (lookup.error === 'ambiguous') {
+        return notify(session, 'error', analyze.notify({
+          type: 'source_ambiguous',
+          bookName,
+          matches: lookup.matches,
+        }));
+      }
+      const sourcePath = lookup.path;
+
+      // 2.6.2 从实际文件路径获取真实文件名（去除后缀）
+      // 必须用 basename：split('/').pop() 在 Windows 上取不到文件名
+      // （路径分隔符是 '\'），会把整条路径当成书名，
+      // 后面拆书就会写到 对标/raw/sources/C:\Users\...\ 这种乱路径下。
+      const sourceFileName = sourcePath ? basename(sourcePath) : bookName;
+      const bookNameClean = sourceFileName.replace(/\.[^./\\]+$/, '');
+
+      // 读取 .fancy-deployed 配置
+      const { config: deployedConfig, errorText: configError } = loadDeployedConfig(projectRoot);
+      if (configError) {
+        return notify(session, 'error', configError);
+      }
+
+      const llmWikiUrl = (deployedConfig.llm_wiki_url || '').replace(/\/$/, '');
+      const llmWikiToken = deployedConfig.llm_wiki_token || '';
+
+      if (!llmWikiUrl || !llmWikiToken) {
+        return notify(session, 'error', analyze.notify({ type: 'llm_wiki_not_configured' }));
+      }
+
+      // 4. 调用 llm_wiki API 创建项目
+      let referenceId = deployedConfig.reference_id || '';
+      try {
+        const result = await callLlmWikiApi(
+          llmWikiUrl,
+          llmWikiToken,
+          '/projects/create',
+          'POST',
+          {
+            name: '对标',
+            path: projectRoot,
+          }
+        );
+
+        if (result.data && result.data.error) {
+          const errorMsg = String(result.data.error);
+          if (errorMsg.includes('Directory already exists')) {
+            // 目录已存在，继续下一步
+          } else {
+            return notify(session, 'error', analyze.notify({ type: 'llm_wiki_failed', err: errorMsg }));
+          }
+        } else if (result.data && result.data.ok === true && result.data.project && result.data.project.id) {
+          // 成功，保存 reference_id
+          referenceId = result.data.project.id;
+          updateDeployedField(projectRoot, 'reference_id', referenceId);
+        } else {
+          // 既不是成功也不是 Directory already exists 错误
+          const apiErr = llmWikiError(result);
+          return notify(session, 'error', analyze.notify({ type: 'llm_wiki_failed', err: apiErr || 'API 调用失败' }));
+        }
+      } catch (err) {
+        const errMsg = describeFetchError(err);
+        return notify(session, 'error', analyze.notify({ type: 'llm_wiki_failed', err: errMsg }));
+      }
+
+      // 5. 拷贝 schema-analyze.md → 对标/schema.md
+      const duiBiaoDir = join(projectRoot, '对标');
+      try {
+        copySchemaFile(duiBiaoDir);
+      } catch (err) {
+        return notify(session, 'error', analyze.notify({ type: 'write_failed', err: err.message }));
+      }
+
+      // 6. 执行拆书脚本 → 对标/raw/sources/<书名>/
+      const splitDir = join(projectRoot, '对标', 'raw', 'sources', bookNameClean);
+      const splitResult = await spawnScript('node', [SPLIT_SCRIPT, '--source', sourcePath, '--output-dir', splitDir], { timeout: 60000 });
+      if (!splitResult.ok) {
+        return notify(session, 'error', analyze.notify({ type: 'split_failed', err: splitResult.error || '未知错误' }));
+      }
+      let splitData;
+      try {
+        splitData = JSON.parse(splitResult.output);
+      } catch {
+        return notify(session, 'error', analyze.notify({ type: 'split_failed', err: '拆书脚本返回格式错误' }));
+      }
+
+      // 7. 调用 llm_wiki sources/ingest 接口
+      //
+      // 这里必须把失败**报给用户**。
+      // 之前只是 try/catch + console.error，可 HTTP 4xx/5xx 根本不抛异常，
+      // catch 压根不触发 —— 于是 ingest 返回 500 时命令照样返回
+      // kind=success + "✅ 正在后台拆解中"，而 llm_wiki 那边一个文件都没收到，
+      // 用户等多久都不会有结果（实测复现）。
+      if (referenceId && splitData && splitData.split_files && splitData.split_files.length > 0) {
+        const paths = splitData.split_files.map(f => `raw/sources/${bookNameClean}/${f}`);
+        try {
+          const ingestResult = await callLlmWikiApi(
+            llmWikiUrl,
+            llmWikiToken,
+            `/projects/${referenceId}/sources/ingest`,
+            'POST',
+            { paths }
+          );
+          const apiErr = llmWikiError(ingestResult);
+          if (apiErr) {
+            console.error(`[fancy-analyze] sources/ingest failed: ${apiErr}`);
+            return notify(session, 'error', analyze.notify({
+              type: 'ingest_failed',
+              err: apiErr,
+              bookNameClean,
+            }));
+          }
+        } catch (err) {
+          const errMsg = describeFetchError(err);
+          console.error(`[fancy-analyze] sources/ingest failed: ${errMsg}`);
+          return notify(session, 'error', analyze.notify({
+            type: 'ingest_failed',
+            err: errMsg,
+            bookNameClean,
+          }));
+        }
+      }
+
+      // 8. 通知用户
+      return notify(session, 'success', analyze.notify({
+        type: 'done',
+        bookNameClean,
+        projectRoot,
+      }));
+    },
+  });
+}