@cloud411716/fancy-webnovel 0.3.16 → 1.0.0

package/infra.js

@@ -1,34 +1,39 @@
 /**
- * infra.js — DSH 插件核心基础设施
+ * infra.js — DSH Plugin Core Infrastructure
  *
- * 提供：
- *   notify(session, text)       — 打印消息给用户（不触发 LLM）
- *   llmFollowup(invocation, prompt) — 发送消息给 LLM，让 LLM 继续处理
- *   startActivity(session)  — 开始 Activity Line 计时，返回 stop 函数
- *   onUserCancel(session, onCancel) — 监听 CTRL+C / ESC 取消信号，返回 stop 函数
- *   spawnScript(cmd, args, opts) — spawn 子进程，解析 stdout JSON
+ * Provides:
+ *   notify(session, text)        — append a user-facing message to the session log
+ *   llmFollowup(invocation,prompt)— hand a prompt to the LLM as a user message
+ *   scanProgress(ctx, phase, data)— emit structured scan progress events
+ *   sleep(ctx, ms)               — DSH-native promise delay via ctx.timeout()
  *
- * 所有 fancy-* 插件均直接 import 此文件。
+ * All fancy-* plugins import from this file.
  */
 
 // --------------------------------------------------------------------------
-// notify — 打印消息给用户（queueMicrotask 避免打断 LLM 输出顺序）
+// notify — append a text message as a session event (no LLM round-trip)
 // --------------------------------------------------------------------------
 
+/**
+ * @param {object} session - DSH Session object
+ * @param {string} text
+ */
 export function notify(session, text) {
-  queueMicrotask(() => {
-    session.append(
-      'user/message',
-      { content: [{ type: 'text', text: String(text) }], source: { kind: 'user' } },
-      { surfaceOp: 'append' }
-    );
-  });
+  session.append(
+    'user/message',
+    { content: [{ type: 'text', text: String(text) }], source: { kind: 'user' } },
+    { surfaceOp: 'append' }
+  );
 }
 
 // --------------------------------------------------------------------------
-// llmFollowup
+// llmFollowup — hand a prompt to the LLM as a user message
 // --------------------------------------------------------------------------
 
+/**
+ * @param {object} invocation - CommandInvocation from ctx.commands handler
+ * @param {string|object} content
+ */
 export function llmFollowup(invocation, content) {
   const prompt = typeof content === 'string' ? content : JSON.stringify(content);
   invocation.agent.followup({
@@ -38,103 +43,79 @@ export function llmFollowup(invocation, content) {
 }
 
 // --------------------------------------------------------------------------
-// startActivity — Activity Line 计时器（显示 Running… + 实时计时）
-// 调用 startActivity() 返回 stop 函数，进入新阶段时先 stop 再 start
+// sleep — DSH-native promise delay using ctx.timeout()
 // --------------------------------------------------------------------------
 
-export function startActivity(session) {
-  session.append('turn/start', { source: 'fancy-plugin' });
-  return () => session.append('turn/end', { source: 'fancy-plugin' });
+/**
+ * Return a promise that resolves after `ms` milliseconds.
+ * Uses ctx.timeout() (Cordis timer service) instead of native setTimeout.
+ *
+ * @param {object} ctx  - Cordis plugin context
+ * @param {number} ms   - milliseconds to wait
+ * @returns {Promise<void>}
+ */
+export function sleep(ctx, ms) {
+  return new Promise((resolve) => {
+    ctx.timeout(resolve, ms);
+  });
 }
 
 // --------------------------------------------------------------------------
-// onUserCancel — 监听用户按 CTRL+C 或 ESC 取消信号
-//
-// 调用时传入 session + onCancel 回调（清理函数，如 kill 子进程、停止计时等）
-// 返回 stop 函数（调用以移除监听器，流程正常结束时调用）
-// 注意：不在弹窗场景下使用（弹窗自身有取消逻辑）
+// scanProgress — emit structured scan progress via DSH events
 // --------------------------------------------------------------------------
-const _cancelHandlers = new Map(); // session → { stopFn, onCancel }
 
-export function onUserCancel(session, onCancel) {
-  if (_cancelHandlers.has(session)) {
-    const existing = _cancelHandlers.get(session);
-    const orig = existing.onCancel;
-    existing.onCancel = () => { orig?.(); onCancel?.(); };
-    return existing.stopFn;
+/**
+ * Emit a scan progress event. These flow into the session log and can be
+ * observed by the running agent for real-time progress feedback.
+ *
+ * @param {object} ctx
+ * @param {'start'|'book'|'rank-done'|'done'} phase
+ * @param {object} data
+ */
+export function scanProgress(ctx, phase, data) {
+  switch (phase) {
+    case 'start':
+      ctx.events.emit('fancy/scan:start', data.platform, data.channel, data.type, data.label);
+      break
+    case 'book':
+      ctx.events.emit('fancy/scan:book', data.platform, data.channel, data.type,
+        data.index, data.total, data.title, data.rank);
+      break
+    case 'rank-done':
+      ctx.events.emit('fancy/scan:rank-done', data.platform, data.channel, data.type,
+        data.ok, data.written, data.failed, data.errorMsg);
+      break
+    case 'done':
+      ctx.events.emit('fancy/scan:done', data.platform, data.totalBooks, data.totalFiles, data.ok);
+      break
   }
-
-  let cancelled = false;
-
-  const handler = () => {
-    if (cancelled) return;
-    cancelled = true;
-    for (const fn of stopFns) { try { fn(); } catch (_) {} }
-    cleanup();
-    notify(session, '🚫 操作已取消。');
-  };
-
-  const cleanup = () => {
-    process.removeListener('SIGINT', handler);
-    _cancelHandlers.delete(session);
-  };
-
-  const stopFns = [onCancel].filter(Boolean);
-  process.on('SIGINT', handler);
-
-  const stopFn = () => {
-    if (!cancelled) {
-      for (const fn of stopFns) { try { fn(); } catch (_) {} }
-      cleanup();
-    }
-  };
-
-  _cancelHandlers.set(session, { stopFn });
-  return stopFn;
 }
 
 // --------------------------------------------------------------------------
-// spawnScript — spawn 子进程，stdout 只收集 JSON，stderr 单独收集
-// opts.stop() 会在进程终止时自动调用（用于清理 turn/start）
+// writeFile / mkdir — Node.js fs, used for project dirs outside workspace
 // --------------------------------------------------------------------------
 
-export function spawnScript(cmd, args, { timeout = 30000, cwd, stop } = {}) {
-  return new Promise(async (resolve) => {
-    const { spawn } = await import('child_process');
-    const proc = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-    const outParts = [], errParts = [];
-    let settled = false;
-    const settle = (v) => { if (!settled) { settled = true; resolve(v); } };
-
-    const timer = timeout > 0 ? setTimeout(() => {
-      proc.kill('SIGTERM');
-      settle({ ok: false, output: outParts.join(''), error: 'timeout after ' + timeout + 'ms' });
-    }, timeout) : null;
-
-    proc.stdout.on('data', (d) => { outParts.push(d.toString()); });
-    proc.stderr.on('data', (d) => { errParts.push(d.toString()); });
+/**
+ * Write text to a file, creating directories as needed.
+ * Uses Node.js fs directly (not ctx.fs) since project roots may be
+ * outside the DSH sandbox workspace.
+ *
+ * @param {string} filepath
+ * @param {string} content
+ * @param {string} [encoding='utf-8']
+ */
+export async function writeFile(filepath, content, encoding = 'utf-8') {
+  const { writeFileSync, mkdirSync } = await import('fs');
+  const { dirname } = await import('path');
+  mkdirSync(dirname(filepath), { recursive: true });
+  writeFileSync(filepath, content, encoding);
+}
 
-    const cleanup = () => { try { stop?.(); } catch (_) {} };
-    proc.on('close', (code) => {
-      clearTimeout(timer);
-      cleanup();
-      if (settled) return;
-      const stdout = outParts.join(''), stderr = errParts.join('');
-      try {
-        const parsed = JSON.parse(stdout);
-        settle({
-          ok: parsed.ok === true,
-          output: stdout,
-          error: parsed.error
-            ? (typeof parsed.error === 'object'
-                ? (parsed.error.message || JSON.stringify(parsed.error))
-                : String(parsed.error))
-            : stderr || undefined,
-        });
-      } catch (_) {
-        settle({ ok: false, output: stdout, error: stderr || ('exit ' + code) });
-      }
-    });
-    proc.on('error', (err) => { clearTimeout(timer); cleanup(); settle({ ok: false, output: '', error: err.message }); });
-  });
+/**
+ * Create a directory, creating parents as needed.
+ * @param {string} dirpath
+ */
+export async function mkdirp(dirpath) {
+  const { mkdirSync } = await import('fs');
+  mkdirSync(dirpath, { recursive: true });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud411716/fancy-webnovel",
-  "version": "0.3.16",
+  "version": "1.0.0",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -9,21 +9,13 @@
   "files": [
     "index.js",
     "infra.js",
-    "templates.js",
+    "events.js",
     "cordis.patch.yml",
-    "plugins/"
+    "commands/"
   ],
   "dependencies": {
     "playwright-core": "1.48.0"
   },
-  "peerDependencies": {
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-llm": {
-      "optional": true
-    }
-  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"

package/plugins/fancy-bootstrap/index.js

@@ -1,100 +0,0 @@
-/**
- * fancy-bootstrap plugin entry
- */
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { existsSync } from 'fs';
-import { notify, spawnScript, startActivity } from '../../infra.js';
-import { bootstrap } from './templates.js';
-
-export const inject = ['commands', 'userQuestions'];
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SCRIPTS_DIR = join(__dirname, 'scripts');
-
-// ---------------------------------------------------------------------------
-// 路径工具
-// ---------------------------------------------------------------------------
-
-function isValidPath(p) {
-  return !p.includes('..') && !/[<>:"'|?*[\x00-\x1f]/.test(p) && !/\s/.test(p);
-}
-
-// ---------------------------------------------------------------------------
-// 注册
-// ---------------------------------------------------------------------------
-
-export async function apply(ctx) {
-  ctx.commands.register({
-    name: 'fancy-bootstrap',
-    description: '📁 初始化项目根 ( usage: /fancy-bootstrap [项目根] )',
-    handler: async (invocation) => {
-      const session = invocation.agent.session;
-      const rawInput = invocation.rawInput ? invocation.rawInput.trim() : '';
-
-      let projectRoot = rawInput;
-
-      // 无参数 → 弹窗
-      if (!projectRoot) {
-        const result = await ctx.userQuestions.ask({
-          questions: [bootstrap.askPath()],
-        });
-        projectRoot = result.answers[0]?.custom?.trim() || '';
-      }
-
-      if (!projectRoot) {
-        notify(session, bootstrap.notify({ type: 'no_path' }));
-        return { kind: 'success', text: '' };
-      }
-
-      if (projectRoot === '.') {
-        projectRoot = process.cwd();
-        notify(session, bootstrap.notify({ type: 'using_cwd', projectRoot }));
-      }
-
-      if (!isValidPath(projectRoot)) {
-        notify(session, bootstrap.notify({ type: 'invalid_path' }));
-        return { kind: 'success', text: '' };
-      }
-
-      if (existsSync(join(projectRoot, '.fancy-deployed'))) {
-        notify(session, bootstrap.notify({ type: 'already_initialized' }));
-        return { kind: 'success', text: '' };
-      }
-
-      const confirm = await ctx.userQuestions.ask({
-        questions: [{
-          id: 'confirm',
-          question: bootstrap.notify({ type: 'confirm', projectRoot }),
-          detail: projectRoot,
-          hideCustomInput: true,
-          options: bootstrap.confirmOptions(),
-        }],
-      });
-      const ans = confirm.answers[0];
-      const chosen = ans?.selected?.[0] ?? ans?.custom;
-      if (chosen !== '确认创建') {
-        notify(session, bootstrap.notify({ type: 'cancelled' }));
-        return { kind: 'success', text: '' };
-      }
-
-      notify(session, bootstrap.notify({ type: 'initializing', projectRoot }));
-      const stopActivity = startActivity(session);
-      const result = await spawnScript('node', [join(SCRIPTS_DIR, 'init.js'), projectRoot], {
-        timeout: 30000,
-        stop: stopActivity,
-      });
-
-      if (result.ok) {
-        notify(session, bootstrap.notify({ type: 'success' }));
-      } else {
-        const err = (typeof result.error === 'object' && result.error !== null)
-          ? (result.error.message || JSON.stringify(result.error))
-          : String(result.error || '未知错误');
-        notify(session, bootstrap.notify({ type: 'error', err }));
-      }
-
-      return { kind: 'success', text: '' };
-    }
-  });
-}

package/plugins/fancy-bootstrap/scripts/init.js

@@ -1,111 +0,0 @@
-/**
- * fancy-bootstrap init — 项目初始化
- */
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { expandHome, resolvePath, joinPath } from './path-utils.js';
-
-const DIRS = [
-  '设定/角色', '设定/势力', '设定/物品', '设定/地点',
-  '大纲', '正文', '故事档案', '对标', '拆文库',
-  '审查报告', '图片', '发布',
-  '故事档案/备份', '故事档案/.快照', '故事档案/派生',
-  '调试', 'RAG索引',
-];
-
-function mkdirp(dir) {
-  mkdirSync(dir, { recursive: true });
-}
-
-function writeJson(filePath, data) {
-  writeFileSync(filePath, JSON.stringify(data), 'utf-8');
-}
-
-function nowIso() {
-  return new Date().toISOString().replace('.000Z', 'Z');
-}
-
-function main() {
-  const projectRootRaw = process.argv[2] ?? '';
-
-  if (projectRootRaw.includes('..') || /[<>:\"'|?*]/.test(projectRootRaw) || /[\x00-\x1f]/.test(projectRootRaw)) {
-    console.log(JSON.stringify({ ok: false, error: { code: 1, code_name: 'EC001', message: '路径不合法' } }));
-    process.exit(1);
-  }
-
-  const projectRoot = resolvePath(expandHome(projectRootRaw));
-  const deployed = joinPath(projectRoot, '.fancy-deployed');
-
-  if (existsSync(deployed)) {
-    console.log(JSON.stringify({ ok: false, error: { code: 2, code_name: 'EC002', message: '项目已存在，不能重复 init' } }));
-    process.exit(2);
-  }
-  if (!existsSync(projectRoot)) {
-    console.log(JSON.stringify({ ok: false, error: { code: 18, code_name: 'EC018', message: `目录不存在: ${projectRoot}` } }));
-    process.exit(18);
-  }
-
-  const now = nowIso();
-
-  try {
-    for (const d of DIRS) mkdirp(joinPath(projectRoot, d));
-
-    writeJson(deployed, {
-      schema_version: '2.0.0', fancy_skills_version: '2.0.0', deployed_at: now,
-      project_root_abs: projectRoot, project_root_rel: '.', current_book: '', books: [], active_book_index: 0,
-    });
-
-    const archive = joinPath(projectRoot, '故事档案');
-    writeJson(joinPath(archive, '_story_state.json'), {
-      schema_version: '2.0.0', last_modified: now,
-      project: { name: '', created_at: now, last_modified: now, genre: '', target_words: 0, target_chapters: 0, platform: '', platform_other: '' },
-      phase: 'uninitialized', phase_history: [{ phase: 'uninitialized', at: now }],
-      state_machine: { current_volume: 1, last_chapter_committed: 0, next_chapter_to_write: 1, chapters_total_words: 0, committed_chapters: [], pause_reason: null, paused_at: null },
-      author_intent: { style: 'xiaobai', pacing: 'medium', pov: 'third', target_audience: 'general', preferences: [], hard_constraints: [], anti_tropes: [], core_summary: '', core_conflict: '', reader_promise: '' },
-      active_book: { project_root: '.', set_at: now },
-    });
-    writeJson(joinPath(archive, '_timeline.json'), {
-      schema_version: '2.0.0', last_modified: now,
-      world_clock: { start_date: now, current_date: now, calendar_unit: 'day' },
-      events: [], character_status_at_chapter: {}, dead_characters: [], fact_log: [], discoveries: [],
-    });
-    writeJson(joinPath(archive, '_character_state.json'), { schema_version: '2.0.0', last_modified: now, characters: {}, info_boundary_log: [] });
-    writeJson(joinPath(archive, '_foreshadows.json'), { schema_version: '2.0.0', last_modified: now, foreshadows: [], type_distribution: {}, open_count: 0 });
-    writeJson(joinPath(archive, '_chapter_index.json'), { schema_version: '2.0.0', last_modified: now, chapters: [] });
-
-    const intentMd = [
-      '# 作者长期意图（Author Intent）',
-      '',
-      '> 由 fancy-bootstrap 自动生成。',
-      '> **注意**：书名/题材/平台/字数等信息在 fancy-topic 阶段填入。',
-      '',
-      '## 项目信息',
-      '> ⚠️ 以下由 fancy-topic 填入：书名 / 题材 / 平台 / 目标字数 / 目标章数',
-      '',
-      '## 故事核心',
-      '> ⚠️ 由 fancy-topic 填入：一句话 / 核心冲突 / 读者承诺',
-      '',
-      '## 风格基调',
-      '- 文风：xiaobai（待 fancy-bible 细化）',
-      '- 节奏：medium（待 fancy-bible 细化）',
-      '- POV：third（待 fancy-bible 细化）',
-      '',
-      `## 用户已声明的偏好`,
-      `- ${now}：项目目录创建（fancy-bootstrap）`,
-    ].join('\n');
-    writeFileSync(joinPath(archive, '_author_intent.md'), intentMd, 'utf-8');
-
-  } catch (e) {
-    const errMsg = e instanceof Error ? e.message : String(e);
-    console.log(JSON.stringify({ ok: false, error: { code: 17, code_name: 'EC017', message: `初始化失败: ${errMsg}` } }));
-    process.exit(17);
-  }
-
-  console.log(JSON.stringify({
-    ok: true, operation: 'init', project_root: projectRoot, phase: 'uninitialized',
-    directories_created: DIRS.length,
-    files_created: ['.fancy-deployed', '故事档案/_story_state.json', '故事档案/_timeline.json', '故事档案/_character_state.json', '故事档案/_foreshadows.json', '故事档案/_chapter_index.json', '故事档案/_author_intent.md'],
-    note: '项目信息由 fancy-topic 填入',
-  }));
-}
-
-main();

package/plugins/fancy-bootstrap/scripts/path-utils.js

@@ -1,22 +0,0 @@
-/**
- * path-utils.js — init.js 专用路径工具
- * restore from git
- */
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { resolve, join } from 'path';
-
-export function expandHome(p) {
-  if (p === '~' || p.startsWith('~/')) {
-    return join(homedir(), p.slice(1));
-  }
-  return p;
-}
-
-export function resolvePath(p) {
-  return resolve(p);
-}
-
-export function joinPath(base, ...parts) {
-  return join(base, ...parts);
-}

package/plugins/fancy-bootstrap/templates.js

@@ -1,41 +0,0 @@
-/**
- * bootstrap 模板 — 仅 fancy-bootstrap 使用
- */
-
-export const bootstrap = {
-  askPath(question = '📂 请输入项目根路径 ( 或者输入 . 代表当前路径 )') {
-    return { question };
-  },
-
-  notify({ type, projectRoot, err }) {
-    switch (type) {
-      case 'no_path':
-        return '⚠️ 未提供路径，已取消';
-      case 'using_cwd':
-        return `📂 使用当前目录：${projectRoot}`;
-      case 'invalid_path':
-        return '❌ 路径不合法（不能含空格、.. 或特殊字符）';
-      case 'already_initialized':
-        return '⚠️ 该目录已初始化（.fancy-deployed 已存在）';
-      case 'confirm':
-        return `❓ 确认将以下路径作为项目根？\n${projectRoot}`;
-      case 'cancelled':
-        return '🚫 已取消';
-      case 'initializing':
-        return `⏳ 正在初始化 ${projectRoot}...`;
-      case 'success':
-        return '✅ 项目初始化完成！\n下一步：运行 /fancy-scan 扫榜';
-      case 'error':
-        return '❌ 初始化失败：' + (typeof err === 'function' ? err() : err);
-      default:
-        return String(type);
-    }
-  },
-
-  confirmOptions() {
-    return [
-      { label: '确认创建' },
-      { label: '取消' },
-    ];
-  },
-};