@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/webhook.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { sendWebhook, type WebhookPayload } from "../notify/webhook.js";
+import { createHmac } from "node:crypto";
+
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+
+beforeEach(() => {
+  mockFetch.mockReset();
+});
+
+const basePayload: WebhookPayload = {
+  event: "chapter-complete",
+  bookId: "test-book",
+  chapterNumber: 5,
+  timestamp: "2026-03-14T00:00:00.000Z",
+  data: { title: "测试章节", wordCount: 3000 },
+};
+
+describe("sendWebhook", () => {
+  it("sends POST request with JSON payload", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true });
+
+    await sendWebhook({ url: "https://example.com/hook" }, basePayload);
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const [url, opts] = mockFetch.mock.calls[0]!;
+    expect(url).toBe("https://example.com/hook");
+    expect(opts.method).toBe("POST");
+    expect(opts.headers["Content-Type"]).toBe("application/json");
+    const body = JSON.parse(opts.body);
+    expect(body.event).toBe("chapter-complete");
+    expect(body.bookId).toBe("test-book");
+  });
+
+  it("includes HMAC signature when secret is configured", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true });
+    const secret = "my-secret-key";
+
+    await sendWebhook({ url: "https://example.com/hook", secret }, basePayload);
+
+    const [, opts] = mockFetch.mock.calls[0]!;
+    const expectedSig = createHmac("sha256", secret)
+      .update(opts.body)
+      .digest("hex");
+    expect(opts.headers["X-InkOS-Signature"]).toBe(`sha256=${expectedSig}`);
+  });
+
+  it("skips event when not in subscribed events list", async () => {
+    await sendWebhook(
+      { url: "https://example.com/hook", events: ["audit-passed"] },
+      basePayload,
+    );
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("sends event when it matches subscribed events list", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true });
+
+    await sendWebhook(
+      { url: "https://example.com/hook", events: ["chapter-complete"] },
+      basePayload,
+    );
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+  });
+
+  it("sends all events when events list is empty", async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true });
+
+    await sendWebhook(
+      { url: "https://example.com/hook", events: [] },
+      basePayload,
+    );
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+  });
+
+  it("throws on non-ok response", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      text: async () => "Internal Server Error",
+    });
+
+    await expect(
+      sendWebhook({ url: "https://example.com/hook" }, basePayload),
+    ).rejects.toThrow("Webhook POST to https://example.com/hook failed: 500");
+  });
+});

package/inkos/packages/core/src/__tests__/writer-parser.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect } from "vitest";
+import { parseWriterOutput, parseCreativeOutput, type ParsedWriterOutput } from "../agents/writer-parser.js";
+import type { GenreProfile } from "../models/genre-profile.js";
+import { countChapterLength } from "../utils/length-metrics.js";
+
+const defaultGenreProfile: GenreProfile = {
+  name: "测试",
+  id: "test",
+  language: "zh",
+  chapterTypes: [],
+  fatigueWords: [],
+  numericalSystem: true,
+  powerScaling: false,
+  eraResearch: false,
+  pacingRule: "",
+  satisfactionTypes: [],
+  auditDimensions: [],
+};
+
+function callParseOutput(
+  chapterNumber: number,
+  content: string,
+  genreProfile: GenreProfile = defaultGenreProfile,
+  countingMode: "zh_chars" | "en_words" = "zh_chars",
+): ParsedWriterOutput {
+  return parseWriterOutput(chapterNumber, content, genreProfile, countingMode);
+}
+
+// ---------------------------------------------------------------------------
+// Full tagged output
+// ---------------------------------------------------------------------------
+
+describe("WriterAgent parseOutput", () => {
+  const fullOutput = [
+    "=== PRE_WRITE_CHECK ===",
+    "| 检查项 | 本章记录 | 备注 |",
+    "|--------|----------|------|",
+    "| 上下文范围 | 第1章 | |",
+    "",
+    "=== CHAPTER_TITLE ===",
+    "吞天之始",
+    "",
+    "=== CHAPTER_CONTENT ===",
+    "陈风站在悬崖边，俯视着脚下的万丈深渊。",
+    "一股强烈的吸力从深渊中传来，仿佛有什么东西在召唤他。",
+    "",
+    "=== POST_SETTLEMENT ===",
+    "| 结算项 | 本章记录 | 备注 |",
+    "|--------|----------|------|",
+    "| 资源账本 | 期初0 / 增量+100 / 期末100 | |",
+    "",
+    "=== UPDATED_STATE ===",
+    "# 状态卡",
+    "| 字段 | 值 |",
+    "|------|-----|",
+    "| 章节 | 1 |",
+    "",
+    "=== UPDATED_LEDGER ===",
+    "# 资源账本",
+    "| 章节 | 期初 | 来源 | 增量 | 期末 |",
+    "|------|------|------|------|------|",
+    "| 1 | 0 | 深渊果实 | +100 | 100 |",
+    "",
+    "=== UPDATED_HOOKS ===",
+    "# 伏笔池",
+    "| ID | 伏笔 | 状态 |",
+    "|-----|------|------|",
+    "| H001 | 深渊之物 | open |",
+  ].join("\n");
+
+  it("extracts all sections from a complete tagged output", () => {
+    const result = callParseOutput(1, fullOutput);
+
+    expect(result.chapterNumber).toBe(1);
+    expect(result.title).toBe("吞天之始");
+    expect(result.content).toContain("陈风站在悬崖边");
+    expect(result.content).toContain("召唤他");
+    expect(result.preWriteCheck).toContain("检查项");
+    expect(result.postSettlement).toContain("资源账本");
+    expect(result.updatedState).toContain("状态卡");
+    expect(result.updatedLedger).toContain("深渊果实");
+    expect(result.updatedHooks).toContain("H001");
+  });
+
+  it("calculates wordCount with the shared counting helper", () => {
+    const result = callParseOutput(1, fullOutput);
+    const expectedContent =
+      "陈风站在悬崖边，俯视着脚下的万丈深渊。\n一股强烈的吸力从深渊中传来，仿佛有什么东西在召唤他。";
+    expect(result.wordCount).toBe(countChapterLength(expectedContent, "zh_chars"));
+  });
+
+  // -------------------------------------------------------------------------
+  // Missing sections
+  // -------------------------------------------------------------------------
+
+  it("returns default title when CHAPTER_TITLE is missing", () => {
+    const output = [
+      "=== CHAPTER_CONTENT ===",
+      "Some content here.",
+    ].join("\n");
+
+    const result = callParseOutput(42, output);
+    expect(result.title).toBe("第42章");
+  });
+
+  it("returns an English default title when CHAPTER_TITLE is missing in English mode", () => {
+    const output = [
+      "=== CHAPTER_CONTENT ===",
+      "Some content here.",
+    ].join("\n");
+
+    const result = callParseOutput(42, output, defaultGenreProfile, "en_words");
+    expect(result.title).toBe("Chapter 42");
+  });
+
+  it("returns empty content when CHAPTER_CONTENT is missing", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "A Title",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.content).toBe("");
+    expect(result.wordCount).toBe(0);
+  });
+
+  it("returns fallback strings for missing state sections", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "Title",
+      "",
+      "=== CHAPTER_CONTENT ===",
+      "Content.",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.updatedState).toBe("(状态卡未更新)");
+    expect(result.updatedLedger).toBe("(账本未更新)");
+    expect(result.updatedHooks).toBe("(伏笔池未更新)");
+  });
+
+  it("returns English fallback strings for missing state sections in English mode", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "Title",
+      "",
+      "=== CHAPTER_CONTENT ===",
+      "Content.",
+    ].join("\n");
+
+    const result = callParseOutput(1, output, defaultGenreProfile, "en_words");
+    expect(result.updatedState).toBe("(state card not updated)");
+    expect(result.updatedLedger).toBe("(ledger not updated)");
+    expect(result.updatedHooks).toBe("(hooks pool not updated)");
+  });
+
+  it("returns empty string for missing PRE_WRITE_CHECK", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "Title",
+      "",
+      "=== CHAPTER_CONTENT ===",
+      "Content.",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.preWriteCheck).toBe("");
+  });
+
+  it("returns empty string for missing POST_SETTLEMENT", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "Title",
+      "",
+      "=== CHAPTER_CONTENT ===",
+      "Content.",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.postSettlement).toBe("");
+  });
+
+  // -------------------------------------------------------------------------
+  // Edge cases
+  // -------------------------------------------------------------------------
+
+  it("handles completely empty input", () => {
+    const result = callParseOutput(1, "");
+    expect(result.chapterNumber).toBe(1);
+    expect(result.title).toBe("第1章");
+    expect(result.content).toBe("");
+    expect(result.wordCount).toBe(0);
+    expect(result.updatedState).toBe("(状态卡未更新)");
+    expect(result.updatedLedger).toBe("(账本未更新)");
+    expect(result.updatedHooks).toBe("(伏笔池未更新)");
+  });
+
+  it("handles content with no tags at all", () => {
+    const result = callParseOutput(5, "Just some random text without tags");
+    expect(result.title).toBe("第5章");
+    expect(result.content).toBe("");
+    expect(result.wordCount).toBe(0);
+  });
+
+  it("preserves multiline content within a section", () => {
+    const output = [
+      "=== CHAPTER_CONTENT ===",
+      "第一段：这里是开头。",
+      "",
+      "第二段：这里是中间。",
+      "",
+      "第三段：这里是结尾。",
+      "",
+      "=== POST_SETTLEMENT ===",
+      "No settlement.",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.content).toContain("第一段");
+    expect(result.content).toContain("第二段");
+    expect(result.content).toContain("第三段");
+  });
+
+  it("trims whitespace from extracted section values", () => {
+    const output = [
+      "=== CHAPTER_TITLE ===",
+      "   吞天之始   ",
+      "",
+      "=== CHAPTER_CONTENT ===",
+      "  内容  ",
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    expect(result.title).toBe("吞天之始");
+    expect(result.content).toBe("内容");
+  });
+
+  it("correctly counts Chinese characters in wordCount", () => {
+    const chineseContent = "这是一段测试文本，包含二十个中文字符加上标点符号。";
+    const output = [
+      "=== CHAPTER_CONTENT ===",
+      chineseContent,
+    ].join("\n");
+
+    const result = callParseOutput(1, output);
+    // wordCount is content.length which counts each character (including punctuation)
+    expect(result.wordCount).toBe(chineseContent.length);
+  });
+
+  it("counts English content with the shared counting helper when requested", () => {
+    const englishContent = "He looked at the sky.";
+    const output = [
+      "=== CHAPTER_CONTENT ===",
+      englishContent,
+    ].join("\n");
+
+    const result = callParseOutput(1, output, defaultGenreProfile, "en_words");
+    expect(result.wordCount).toBe(countChapterLength(englishContent, "en_words"));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Fallback parsing for local/small models (#13)
+// ---------------------------------------------------------------------------
+
+describe("parseCreativeOutput fallback", () => {
+  it("extracts content from markdown heading when tags are missing", () => {
+    const raw = `# 第1章 觉醒之日
+
+林风缓缓睁开了眼睛，映入眼帘的是一片陌生的天花板。他的脑海中充斥着混乱的记忆碎片，${"一段很长的正文内容".repeat(30)}完。`;
+
+    const result = parseCreativeOutput(1, raw);
+    expect(result.title).toBe("觉醒之日");
+    expect(result.content.length).toBeGreaterThan(100);
+    expect(result.content).toContain("林风");
+  });
+
+  it("extracts English content from markdown headings when tags are missing", () => {
+    const raw = `# Chapter 1: Awakening Day
+
+He woke to the sound of distant bells and the taste of salt in the air. ${"Long English prose follows. ".repeat(15)}`;
+
+    const result = parseCreativeOutput(1, raw, "en_words");
+    expect(result.title).toBe("Awakening Day");
+    expect(result.content.length).toBeGreaterThan(100);
+    expect(result.content).toContain("distant bells");
+  });
+
+  it("extracts content from 正文 label when tags are missing", () => {
+    const raw = `章节标题：暗夜追踪
+
+正文：
+${"黑暗中一道身影掠过屋顶，无声无息。".repeat(20)}`;
+
+    const result = parseCreativeOutput(5, raw);
+    expect(result.title).toBe("暗夜追踪");
+    expect(result.content.length).toBeGreaterThan(100);
+  });
+
+  it("falls back to longest prose block when no structure is found", () => {
+    const prose = "这是一段完整的小说正文，描述了主角在黑暗中探索未知世界的经历。".repeat(10);
+    const raw = `PRE_WRITE_CHECK: 已完成自检
+CHAPTER_TITLE: 探索
+
+${prose}`;
+
+    const result = parseCreativeOutput(3, raw);
+    expect(result.content.length).toBeGreaterThan(100);
+  });
+
+  it("returns empty content when raw output is too short", () => {
+    const result = parseCreativeOutput(1, "太短了");
+    expect(result.content).toBe("");
+    expect(result.title).toBe("第1章");
+  });
+
+  it("returns an English fallback title when short English output has no structure", () => {
+    const result = parseCreativeOutput(1, "too short", "en_words");
+    expect(result.content).toBe("");
+    expect(result.title).toBe("Chapter 1");
+  });
+
+  it("still works with proper === TAG === format", () => {
+    const raw = `=== PRE_WRITE_CHECK ===
+自检完成
+
+=== CHAPTER_TITLE ===
+正常标题
+
+=== CHAPTER_CONTENT ===
+正常的章节内容，这里是完整的正文。`;
+
+    const result = parseCreativeOutput(1, raw);
+    expect(result.title).toBe("正常标题");
+    expect(result.content).toBe("正常的章节内容，这里是完整的正文。");
+  });
+
+  it("counts creative output with the shared helper when a counting mode is supplied", () => {
+    const raw = `=== CHAPTER_TITLE ===
+English Chapter
+
+=== CHAPTER_CONTENT ===
+He looked at the sky.`;
+
+    const result = parseCreativeOutput(1, raw, "en_words");
+    expect(result.wordCount).toBe(countChapterLength("He looked at the sky.", "en_words"));
+  });
+});

package/inkos/packages/core/src/__tests__/writer-prompts.test.ts

@@ -0,0 +1,269 @@
+import { describe, expect, it } from "vitest";
+import type { BookConfig } from "../models/book.js";
+import type { GenreProfile } from "../models/genre-profile.js";
+import { LengthSpecSchema } from "../models/length-governance.js";
+import { buildWriterSystemPrompt, buildGoldenOpeningDiscipline } from "../agents/writer-prompts.js";
+
+const BOOK: BookConfig = {
+  id: "prompt-book",
+  title: "Prompt Book",
+  platform: "tomato",
+  genre: "other",
+  status: "active",
+  targetChapters: 20,
+  chapterWordCount: 3000,
+  createdAt: "2026-03-22T00:00:00.000Z",
+  updatedAt: "2026-03-22T00:00:00.000Z",
+};
+
+const GENRE: GenreProfile = {
+  id: "other",
+  name: "综合",
+  language: "zh",
+  chapterTypes: ["setup", "conflict"],
+  fatigueWords: [],
+  numericalSystem: false,
+  powerScaling: false,
+  eraResearch: false,
+  pacingRule: "",
+  satisfactionTypes: [],
+  auditDimensions: [],
+};
+
+describe("buildWriterSystemPrompt", () => {
+  it("includes writing methodology blocks in governed mode", () => {
+    const prompt = buildWriterSystemPrompt(
+      BOOK,
+      GENRE,
+      null,
+      "# Book Rules",
+      "# Genre Body",
+      "# Style Guide\n\nKeep the prose restrained.",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "zh",
+      "governed",
+    );
+
+    expect(prompt).toContain("## 输入治理契约");
+    expect(prompt).toContain("卷纲是默认规划");
+    // v10: compact craft card replaces full methodology modules
+    expect(prompt).toContain("写作铁律");
+    expect(prompt).toContain("盐溶于汤");
+    expect(prompt).toContain("黄金3章");
+  });
+
+  it("uses target-range wording when a length spec is provided", () => {
+    const lengthSpec = LengthSpecSchema.parse({
+      target: 2200,
+      softMin: 1900,
+      softMax: 2500,
+      hardMin: 1600,
+      hardMax: 2800,
+      countingMode: "zh_chars",
+      normalizeMode: "none",
+    });
+
+    const prompt = buildWriterSystemPrompt(
+      BOOK,
+      GENRE,
+      null,
+      "# Book Rules",
+      "# Genre Body",
+      "# Style Guide\n\nKeep the prose restrained.",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "zh",
+      "governed",
+      lengthSpec,
+    );
+
+    expect(prompt).toContain("目标字数：2200");
+    expect(prompt).toContain("允许区间：1900-2500");
+    expect(prompt).not.toContain("正文不少于2200字");
+  });
+
+  it("keeps hard guardrails and book/style constraints in governed mode", () => {
+    const prompt = buildWriterSystemPrompt(
+      BOOK,
+      GENRE,
+      null,
+      "# Book Rules\n\n- Do not reveal the mastermind.",
+      "# Genre Body",
+      "# Style Guide\n\nKeep the prose restrained.",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "zh",
+      "governed",
+    );
+
+    expect(prompt).toContain("## 核心规则");
+    expect(prompt).toContain("## 硬性禁令");
+    expect(prompt).toContain("Do not reveal the mastermind");
+    expect(prompt).toContain("Keep the prose restrained");
+  });
+
+  it("injects the creative constitution and six pillars of immersion as prose (zh)", () => {
+    const prompt = buildWriterSystemPrompt(
+      BOOK,
+      GENRE,
+      null,
+      "# Book Rules",
+      "# Genre Body",
+      "# Style Guide",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "zh",
+      "governed",
+    );
+
+    // Constitution and pillars appear as prose section headings.
+    expect(prompt).toContain("## 创作宪法");
+    expect(prompt).toContain("## 代入感六支柱");
+    // Constitution prose beats — verify a few load-bearing phrases ship.
+    expect(prompt).toContain("盐溶于汤");
+    expect(prompt).toContain("全员智商在线");
+    expect(prompt).toContain("拒绝流水账");
+    // Pillar prose beats — ensure six-pillar content is present.
+    expect(prompt).toContain("基础信息标签化");
+    expect(prompt).toContain("可视化熟悉感");
+    expect(prompt).toContain("五感钩子");
+    // Must NOT be rendered as a numbered checklist — writer must internalise.
+    expect(prompt).not.toContain("1. 基础信息标签化");
+    expect(prompt).not.toContain("- 基础信息标签化");
+  });
+
+  it("injects the creative constitution and six pillars of immersion as prose (en)", () => {
+    const prompt = buildWriterSystemPrompt(
+      { ...BOOK, language: "en" },
+      { ...GENRE, language: "en", name: "General" },
+      null,
+      "# Book Rules",
+      "# Genre Body",
+      "# Style Guide",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "en",
+      "governed",
+    );
+
+    expect(prompt).toContain("## Creative Constitution");
+    expect(prompt).toContain("## Six Pillars of Immersion");
+    expect(prompt).toContain("salt in soup");
+    expect(prompt).toContain("Refuse chronicle drift");
+    expect(prompt).toContain("core tag plus one contrasting detail");
+  });
+
+  it("injects golden opening discipline into zh writer system prompt for ch<=3", () => {
+    for (const ch of [1, 2, 3]) {
+      const prompt = buildWriterSystemPrompt(
+        BOOK,
+        GENRE,
+        null,
+        "# Book Rules",
+        "# Genre Body",
+        "# Style Guide",
+        undefined,
+        ch,
+        "creative",
+        undefined,
+        "zh",
+        "governed",
+      );
+      expect(prompt).toContain("黄金三章写作纪律");
+      expect(prompt).toContain(`第 ${ch} 章`);
+    }
+  });
+
+  it("injects golden opening discipline into en writer system prompt for ch<=3", () => {
+    for (const ch of [1, 2, 3]) {
+      const prompt = buildWriterSystemPrompt(
+        BOOK,
+        { ...GENRE, language: "en", name: "General" },
+        null,
+        "# Book Rules",
+        "# Genre Body",
+        "# Style Guide",
+        undefined,
+        ch,
+        "creative",
+        undefined,
+        "en",
+        "governed",
+      );
+      expect(prompt).toContain("Golden Opening Discipline");
+      expect(prompt).toContain(`Chapter ${ch}`);
+    }
+  });
+
+  it("omits golden opening discipline for ch>=4 in both languages", () => {
+    const zh = buildWriterSystemPrompt(
+      BOOK, GENRE, null, "# Book Rules", "# Genre Body", "# Style Guide",
+      undefined, 4, "creative", undefined, "zh", "governed",
+    );
+    expect(zh).not.toContain("黄金三章写作纪律");
+
+    const en = buildWriterSystemPrompt(
+      BOOK, { ...GENRE, language: "en", name: "General" }, null,
+      "# Book Rules", "# Genre Body", "# Style Guide",
+      undefined, 4, "creative", undefined, "en", "governed",
+    );
+    expect(en).not.toContain("Golden Opening Discipline");
+  });
+
+  it("renders golden opening discipline as cohesive prose, not a checklist", () => {
+    const out = buildGoldenOpeningDiscipline(1, "zh");
+    // Header line is allowed; body must not contain enumerated/bulleted lines.
+    expect(out).not.toMatch(/^\s*1\.\s/m);
+    expect(out).not.toMatch(/^\s*-\s/m);
+    expect(out).not.toMatch(/^\s*\*\s/m);
+    // Carries the load-bearing slot constraints.
+    expect(out).toContain("800 字");
+    expect(out).toContain("做出来");
+    expect(out).toContain("说出来");
+    expect(out).toContain("小钩子");
+  });
+
+  it("buildGoldenOpeningDiscipline returns empty string for ch>=4 / undefined", () => {
+    expect(buildGoldenOpeningDiscipline(4, "zh")).toBe("");
+    expect(buildGoldenOpeningDiscipline(99, "en")).toBe("");
+    expect(buildGoldenOpeningDiscipline(undefined, "zh")).toBe("");
+  });
+
+  it("tells governed English prompts to obey variance briefs and include resistance-bearing exchanges", () => {
+    const prompt = buildWriterSystemPrompt(
+      {
+        ...BOOK,
+        language: "en",
+      },
+      {
+        ...GENRE,
+        language: "en",
+        name: "General",
+      },
+      null,
+      "# Book Rules",
+      "# Genre Body",
+      "# Style Guide\n\nKeep the prose restrained.",
+      undefined,
+      3,
+      "creative",
+      undefined,
+      "en",
+      "governed",
+    );
+
+    expect(prompt).toContain("English Variance Brief");
+    expect(prompt).toContain("resistance-bearing exchange");
+  });
+});