@zwbigi/ink-xy 0.1.2 → 0.1.4

package/inkos/packages/core/src/__tests__/chapter-review-cycle.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, it, vi } from "vitest";
+import { runChapterReviewCycle } from "../pipeline/chapter-review-cycle.js";
+import type { AuditResult, AuditIssue } from "../agents/continuity.js";
+import type { LengthSpec } from "../models/length-governance.js";
+
+const LENGTH_SPEC: LengthSpec = {
+  target: 220,
+  softMin: 190,
+  softMax: 250,
+  hardMin: 160,
+  hardMax: 280,
+  countingMode: "zh_chars",
+  normalizeMode: "none",
+};
+
+const ZERO_USAGE: { promptTokens: number; completionTokens: number; totalTokens: number } = {
+  promptTokens: 0,
+  completionTokens: 0,
+  totalTokens: 0,
+};
+
+function createAuditResult(overrides?: Partial<AuditResult>): AuditResult {
+  return {
+    passed: true,
+    issues: [],
+    summary: "clean",
+    overallScore: 90,
+    ...overrides,
+  };
+}
+
+const baseParams = {
+  book: { genre: "xuanhuan" },
+  bookDir: "/tmp/book",
+  chapterNumber: 1,
+  lengthSpec: LENGTH_SPEC,
+  reducedControlInput: undefined,
+  initialUsage: ZERO_USAGE,
+  assertChapterContentNotEmpty: () => undefined,
+  addUsage: (left: typeof ZERO_USAGE, right?: typeof ZERO_USAGE) => ({
+    promptTokens: left.promptTokens + (right?.promptTokens ?? 0),
+    completionTokens: left.completionTokens + (right?.completionTokens ?? 0),
+    totalTokens: left.totalTokens + (right?.totalTokens ?? 0),
+  }),
+  analyzeAITells: () => ({ issues: [] as AuditIssue[] }),
+  analyzeSensitiveWords: () => ({ found: [] as Array<{ severity: "warn" | "block" }>, issues: [] as AuditIssue[] }),
+  logWarn: () => undefined,
+  logStage: () => undefined,
+} as const;
+
+describe("runChapterReviewCycle v9", () => {
+  it("feeds postWriteErrors as extra issues into first assessment", async () => {
+    // postWriteErrors are critical → auditResult.passed forced false
+    // even though LLM says passed=true. This triggers the repair loop.
+    const auditChapter = vi.fn()
+      .mockResolvedValueOnce(createAuditResult({ overallScore: 90, passed: true }))
+      .mockResolvedValueOnce(createAuditResult({ overallScore: 92, passed: true }));
+    const reviseChapter = vi.fn().mockResolvedValue({
+      revisedContent: "a".repeat(200),
+      wordCount: 200,
+      fixedIssues: ["fixed"],
+      updatedState: "",
+      updatedLedger: "",
+      updatedHooks: "",
+      tokenUsage: ZERO_USAGE,
+    });
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockImplementation(async (content: string) => ({
+        content,
+        wordCount: content.length,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      }));
+
+    const result = await runChapterReviewCycle({
+      ...baseParams,
+      initialOutput: {
+        content: "b".repeat(200),
+        wordCount: 200,
+        postWriteErrors: [{
+          rule: "chapter-number-reference",
+          description: "contains chapter ref",
+          suggestion: "remove it",
+          severity: "error",
+        }],
+      },
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+      // Simulates: the reviser fixed the chapter-ref, so re-check returns empty
+      runPostWriteChecks: (content) =>
+        content === "b".repeat(200)
+          ? [{ severity: "critical" as const, category: "chapter-number-reference", description: "contains chapter ref", suggestion: "remove it" }]
+          : [],
+    });
+
+    // After repair, postWriteChecks on the revised content returns empty → issue gone
+    expect(result.auditResult.issues.some(i => i.category === "chapter-number-reference")).toBe(false);
+    // The loop should have run at least once to fix the critical postWriteError
+    expect(reviseChapter).toHaveBeenCalled();
+    expect(reviseChapter.mock.calls[0]?.[4]).toBe("auto");
+  });
+
+  it("runs repair loop when score is below threshold, picks best version", async () => {
+    const auditChapter = vi.fn()
+      .mockResolvedValueOnce(createAuditResult({
+        passed: false,
+        overallScore: 70,
+        issues: [{ severity: "critical", category: "continuity", description: "broken", suggestion: "fix" }],
+      }))
+      .mockResolvedValueOnce(createAuditResult({
+        passed: false,
+        overallScore: 80,
+        issues: [{ severity: "warning", category: "pacing", description: "slow", suggestion: "trim" }],
+      }))
+      .mockResolvedValueOnce(createAuditResult({
+        passed: false,
+        overallScore: 76,
+        issues: [{ severity: "warning", category: "pacing", description: "still slow", suggestion: "trim more" }],
+      }));
+
+    const reviseChapter = vi.fn()
+      .mockResolvedValueOnce({
+        revisedContent: "a".repeat(200),
+        wordCount: 200,
+        fixedIssues: ["fixed continuity"],
+        updatedState: "", updatedLedger: "", updatedHooks: "",
+        tokenUsage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        revisedContent: "b".repeat(200),
+        wordCount: 200,
+        fixedIssues: ["trimmed pacing"],
+        updatedState: "", updatedLedger: "", updatedHooks: "",
+        tokenUsage: ZERO_USAGE,
+      });
+
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockImplementation(async (content: string) => ({
+        content,
+        wordCount: content.length,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      }));
+
+    const result = await runChapterReviewCycle({
+      ...baseParams,
+      initialOutput: {
+        content: "c".repeat(200),
+        wordCount: 200,
+        postWriteErrors: [],
+      },
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+      maxReviewIterations: 2,
+    });
+
+    // Should have attempted 2 revisions:
+    // iter 1: 70 → 80 (+10, net improvement)
+    // iter 2: 80 → 76 (no net improvement, stop)
+    expect(reviseChapter).toHaveBeenCalledTimes(2);
+    expect(reviseChapter.mock.calls[0]?.[4]).toBe("auto");
+
+    // Best version should be picked (score 80 from iter 1)
+    expect(result.auditResult.overallScore).toBe(80);
+    expect(result.finalContent).toBe("a".repeat(200));
+    expect(result.revised).toBe(true);
+  });
+
+  it("defaults to one automatic repair pass", async () => {
+    const auditChapter = vi.fn()
+      .mockResolvedValueOnce(createAuditResult({
+        passed: false,
+        overallScore: 70,
+        issues: [{ severity: "critical", category: "continuity", description: "broken", suggestion: "fix" }],
+      }))
+      .mockResolvedValueOnce(createAuditResult({
+        passed: false,
+        overallScore: 80,
+        issues: [{ severity: "warning", category: "pacing", description: "slow", suggestion: "trim" }],
+      }))
+      .mockResolvedValueOnce(createAuditResult({
+        passed: true,
+        overallScore: 90,
+      }));
+
+    const reviseChapter = vi.fn()
+      .mockResolvedValueOnce({
+        revisedContent: "a".repeat(200),
+        wordCount: 200,
+        fixedIssues: ["fixed continuity"],
+        updatedState: "", updatedLedger: "", updatedHooks: "",
+        tokenUsage: ZERO_USAGE,
+      })
+      .mockResolvedValueOnce({
+        revisedContent: "b".repeat(200),
+        wordCount: 200,
+        fixedIssues: ["trimmed pacing"],
+        updatedState: "", updatedLedger: "", updatedHooks: "",
+        tokenUsage: ZERO_USAGE,
+      });
+
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockImplementation(async (content: string) => ({
+        content,
+        wordCount: content.length,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      }));
+
+    const result = await runChapterReviewCycle({
+      ...baseParams,
+      initialOutput: {
+        content: "c".repeat(200),
+        wordCount: 200,
+        postWriteErrors: [],
+      },
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+    });
+
+    expect(reviseChapter).toHaveBeenCalledTimes(1);
+    expect(result.auditResult.overallScore).toBe(80);
+    expect(result.finalContent).toBe("a".repeat(200));
+  });
+
+  it("stops immediately when initial score passes threshold", async () => {
+    const auditChapter = vi.fn()
+      .mockResolvedValue(createAuditResult({ overallScore: 88 }));
+    const reviseChapter = vi.fn();
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockImplementation(async (content: string) => ({
+        content,
+        wordCount: content.length,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      }));
+
+    const result = await runChapterReviewCycle({
+      ...baseParams,
+      initialOutput: {
+        content: "d".repeat(200),
+        wordCount: 200,
+        postWriteErrors: [],
+      },
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+    });
+
+    // No revision should have been called
+    expect(reviseChapter).not.toHaveBeenCalled();
+    expect(result.auditResult.overallScore).toBe(88);
+    expect(result.revised).toBe(false);
+  });
+
+  it("normalizes deterministic surface blockers before audit and repair", async () => {
+    const auditChapter = vi.fn()
+      .mockResolvedValue(createAuditResult({ overallScore: 90, passed: true }));
+    const reviseChapter = vi.fn();
+    const normalizeDraftLengthIfNeeded = vi.fn()
+      .mockImplementation(async (content: string) => ({
+        content,
+        wordCount: content.length,
+        applied: false,
+        tokenUsage: ZERO_USAGE,
+      }));
+    const unsafe = `${"雨".repeat(100)}——${"夜".repeat(98)}`;
+
+    const result = await runChapterReviewCycle({
+      ...baseParams,
+      initialOutput: {
+        content: unsafe,
+        wordCount: unsafe.length,
+        postWriteErrors: [],
+      },
+      createReviser: () => ({ reviseChapter }),
+      auditor: { auditChapter },
+      normalizeDraftLengthIfNeeded,
+      normalizePostWriteSurface: (content) => content.replace(/——+/g, "，"),
+      runPostWriteChecks: (content) =>
+        content.includes("——")
+          ? [{ severity: "critical" as const, category: "禁止破折号", description: "出现了破折号", suggestion: "用逗号断句" }]
+          : [],
+    });
+
+    expect(auditChapter.mock.calls[0]?.[1]).not.toContain("——");
+    expect(result.finalContent).not.toContain("——");
+    expect(result.auditResult.passed).toBe(true);
+    expect(reviseChapter).not.toHaveBeenCalled();
+  });
+});

package/inkos/packages/core/src/__tests__/chapter-splitter.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from "vitest";
+import { splitChapters } from "../utils/chapter-splitter.js";
+
+describe("splitChapters", () => {
+  it("splits classical Chinese chapter headings with 第X回 by default", () => {
+    const input = [
+      "第一回：宴桃園豪傑三結義，斬黃巾英雄首立功",
+      "",
+      "滾滾長江東逝水，浪花淘盡英雄。",
+      "",
+      "第二回：張翼德怒鞭督郵，何國舅謀誅宦豎",
+      "",
+      "且說董卓專權，朝野震動。",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(2);
+    expect(chapters[0]).toEqual({
+      title: "宴桃園豪傑三結義，斬黃巾英雄首立功",
+      content: "滾滾長江東逝水，浪花淘盡英雄。",
+    });
+    expect(chapters[1]).toEqual({
+      title: "張翼德怒鞭督郵，何國舅謀誅宦豎",
+      content: "且說董卓專權，朝野震動。",
+    });
+  });
+
+  it("uses a 第N回 fallback title when a classical Chinese heading has no title text", () => {
+    const input = [
+      "第一回",
+      "",
+      "天下大勢，分久必合，合久必分。",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(1);
+    expect(chapters[0]?.title).toBe("第1回");
+  });
+
+  it("splits classical Chinese headings that use the round-zero numeral form", () => {
+    const input = [
+      "第九十九回：孔明秋雨退魏兵",
+      "",
+      "未知孔明怎生破魏，且看下文分解。",
+      "",
+      "第一○○回：漢兵劫寨破曹真，武侯鬥陣辱仲達",
+      "",
+      "卻說眾將聞孔明不追魏兵，俱入帳告曰。",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(2);
+    expect(chapters[0]).toEqual({
+      title: "孔明秋雨退魏兵",
+      content: "未知孔明怎生破魏，且看下文分解。",
+    });
+    expect(chapters[1]).toEqual({
+      title: "漢兵劫寨破曹真，武侯鬥陣辱仲達",
+      content: "卻說眾將聞孔明不追魏兵，俱入帳告曰。",
+    });
+  });
+
+  it("splits English chapter headings with the default pattern", () => {
+    const input = [
+      "Chapter 1: Prelude",
+      "",
+      "The harbor bells rang before dawn.",
+      "",
+      "Chapter 2: Into the Fog",
+      "",
+      "Mara followed the last lantern into the mist.",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(2);
+    expect(chapters[0]).toEqual({
+      title: "Prelude",
+      content: "The harbor bells rang before dawn.",
+    });
+    expect(chapters[1]).toEqual({
+      title: "Into the Fog",
+      content: "Mara followed the last lantern into the mist.",
+    });
+  });
+
+  it("uses an English fallback title when the chapter heading has no title text", () => {
+    const input = [
+      "Chapter 1",
+      "",
+      "The harbor bells rang before dawn.",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(1);
+    expect(chapters[0]?.title).toBe("Chapter 1");
+  });
+
+  it("splits Roman numeral English chapter headings with the default pattern", () => {
+    const input = [
+      "CHAPTER I.",
+      "",
+      "The harbor bells rang before dawn.",
+      "",
+      "CHAPTER II.",
+      "",
+      "Mara followed the last lantern into the mist.",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(2);
+    expect(chapters[0]).toEqual({
+      title: "Chapter 1",
+      content: "The harbor bells rang before dawn.",
+    });
+    expect(chapters[1]).toEqual({
+      title: "Chapter 2",
+      content: "Mara followed the last lantern into the mist.",
+    });
+  });
+
+  it("keeps English fallback titles when a custom regex matches Roman numeral headings", () => {
+    const input = [
+      "CHAPTER I.",
+      "",
+      "The harbor bells rang before dawn.",
+    ].join("\n");
+
+    const chapters = splitChapters(input, "^CHAPTER\\s+[IVXLCDM]+\\.$");
+
+    expect(chapters).toHaveLength(1);
+    expect(chapters[0]?.title).toBe("Chapter 1");
+  });
+
+  it("strips a Project Gutenberg trailer from the final chapter content", () => {
+    const input = [
+      "Chapter 1: Finale",
+      "",
+      "The harbor bells rang once and went silent.",
+      "",
+      "Project Gutenberg™ depends upon and cannot survive without widespread",
+      "public support and donations to carry out its mission.",
+    ].join("\n");
+
+    const chapters = splitChapters(input);
+
+    expect(chapters).toHaveLength(1);
+    expect(chapters[0]?.content).toBe("The harbor bells rang once and went silent.");
+    expect(chapters[0]?.content).not.toContain("Project Gutenberg");
+  });
+});

package/inkos/packages/core/src/__tests__/chapter-state-recovery.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AuditIssue } from "../agents/continuity.js";
+import type {
+  ValidationResult,
+  ValidationWarning,
+} from "../agents/state-validator.js";
+import type { WriteChapterOutput } from "../agents/writer.js";
+import type { BookConfig } from "../models/book.js";
+import type { ChapterMeta } from "../models/chapter.js";
+import {
+  buildStateDegradedPersistenceOutput,
+  buildStateDegradedReviewNote,
+  parseStateDegradedReviewNote,
+  resolveStateDegradedBaseStatus,
+  retrySettlementAfterValidationFailure,
+} from "../pipeline/chapter-state-recovery.js";
+
+function createBook(): BookConfig {
+  return {
+    id: "test-book",
+    title: "Test Book",
+    platform: "tomato",
+    genre: "xuanhuan",
+    status: "active",
+    targetChapters: 10,
+    chapterWordCount: 3000,
+    createdAt: "2026-04-01T00:00:00.000Z",
+    updatedAt: "2026-04-01T00:00:00.000Z",
+  };
+}
+
+function createValidationWarning(
+  overrides: Partial<ValidationWarning> = {},
+): ValidationWarning {
+  return {
+    category: overrides.category ?? "current-state",
+    description: overrides.description ?? "铜牌位置与正文矛盾",
+  };
+}
+
+function createValidationResult(
+  overrides: Partial<ValidationResult> = {},
+): ValidationResult {
+  return {
+    passed: overrides.passed ?? false,
+    warnings: overrides.warnings ?? [createValidationWarning()],
+  };
+}
+
+function createWriteChapterOutput(
+  overrides: Partial<WriteChapterOutput> = {},
+): WriteChapterOutput {
+  return {
+    chapterNumber: 3,
+    title: "第三章",
+    content: "铜牌贴在胸口。",
+    wordCount: "铜牌贴在胸口。".length,
+    preWriteCheck: "ok",
+    postSettlement: "ok",
+    updatedState: "new state",
+    updatedLedger: "new ledger",
+    updatedHooks: "new hooks",
+    chapterSummary: "| 3 | 第三章 |",
+    updatedSubplots: "new subplots",
+    updatedEmotionalArcs: "new emotional arcs",
+    updatedCharacterMatrix: "new character matrix",
+    postWriteErrors: [],
+    postWriteWarnings: [],
+    ...overrides,
+  };
+}
+
+function createChapterMeta(
+  overrides: Partial<ChapterMeta> = {},
+): ChapterMeta {
+  return {
+    number: 3,
+    title: "第三章",
+    status: "state-degraded",
+    wordCount: 1200,
+    createdAt: "2026-04-01T00:00:00.000Z",
+    updatedAt: "2026-04-01T00:00:00.000Z",
+    auditIssues: [],
+    lengthWarnings: [],
+    ...overrides,
+  };
+}
+
+describe("chapter-state-recovery", () => {
+  it("retries settlement with localized validation feedback and recovers on a clean retry", async () => {
+    let capturedFeedback = "";
+    const writer = {
+      settleChapterState: vi.fn(async (input: { validationFeedback?: string }) => {
+        capturedFeedback = input.validationFeedback ?? "";
+        return createWriteChapterOutput({
+          updatedState: "fixed state",
+          updatedHooks: "fixed hooks",
+        });
+      }),
+    };
+    const validator = {
+      validate: vi.fn(async () => createValidationResult({
+        passed: true,
+        warnings: [],
+      })),
+    };
+    const logWarn = vi.fn();
+    const warn = vi.fn();
+
+    const result = await retrySettlementAfterValidationFailure({
+      writer: writer as never,
+      validator: validator as never,
+      book: createBook(),
+      bookDir: "/tmp/test-book",
+      chapterNumber: 3,
+      title: "第三章",
+      content: "铜牌贴在胸口。",
+      oldState: "old state",
+      oldHooks: "old hooks",
+      originalValidation: createValidationResult(),
+      language: "zh",
+      logWarn,
+      logger: { warn } as never,
+    });
+
+    expect(result.kind).toBe("recovered");
+    expect(capturedFeedback).toContain("上一次状态结算未通过校验");
+    expect(capturedFeedback).toContain("铜牌位置与正文矛盾");
+    expect(writer.settleChapterState).toHaveBeenCalledWith(expect.objectContaining({
+      allowReapply: true,
+    }));
+    expect(logWarn).toHaveBeenCalledWith(expect.objectContaining({
+      zh: expect.stringContaining("仅重试结算层"),
+    }));
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("returns localized degraded issues when settlement retry still fails", async () => {
+    const validatorWarning = createValidationWarning({
+      description: "挂坠状态仍与正文冲突",
+    });
+    const result = await retrySettlementAfterValidationFailure({
+      writer: {
+        settleChapterState: vi.fn(async () => createWriteChapterOutput()),
+      } as never,
+      validator: {
+        validate: vi.fn(async () => createValidationResult({
+          passed: false,
+          warnings: [validatorWarning],
+        })),
+      } as never,
+      book: createBook(),
+      bookDir: "/tmp/test-book",
+      chapterNumber: 3,
+      title: "第三章",
+      content: "铜牌贴在胸口。",
+      oldState: "old state",
+      oldHooks: "old hooks",
+      originalValidation: createValidationResult({
+        warnings: [validatorWarning],
+      }),
+      language: "zh",
+      logWarn: vi.fn(),
+      logger: { warn: vi.fn() } as never,
+    });
+
+    expect(result.kind).toBe("degraded");
+    if (result.kind === "degraded") {
+      expect(result.issues).toEqual([
+        expect.objectContaining({
+          category: "state-validation",
+          description: "挂坠状态仍与正文冲突",
+          suggestion: "请先基于已保存正文修复本章 state，再继续后续章节。",
+        }),
+      ]);
+    }
+  });
+
+  it("freezes truth outputs when degrading persisted settlement", () => {
+    const output = createWriteChapterOutput({
+      runtimeStateDelta: { chapter: 3 } as never,
+      runtimeStateSnapshot: {
+        chapter: 3,
+        facts: [],
+        hooks: [],
+        chapterSummary: undefined,
+      } as never,
+      updatedChapterSummaries: "| 3 | 新摘要 |",
+    });
+
+    const degraded = buildStateDegradedPersistenceOutput({
+      output,
+      oldState: "stable state",
+      oldHooks: "stable hooks",
+      oldLedger: "stable ledger",
+    });
+
+    expect(degraded.updatedState).toBe("stable state");
+    expect(degraded.updatedHooks).toBe("stable hooks");
+    expect(degraded.updatedLedger).toBe("stable ledger");
+    expect(degraded.runtimeStateDelta).toBeUndefined();
+    expect(degraded.runtimeStateSnapshot).toBeUndefined();
+    expect(degraded.updatedChapterSummaries).toBeUndefined();
+  });
+
+  it("round-trips degraded review metadata and resolves fallback base status", () => {
+    const issues: AuditIssue[] = [{
+      severity: "warning",
+      category: "state-validation",
+      description: "状态结算重试后仍未通过校验。",
+      suggestion: "请先基于已保存正文修复本章 state，再继续后续章节。",
+    }];
+    const note = buildStateDegradedReviewNote("audit-failed", issues);
+
+    expect(parseStateDegradedReviewNote(note)).toEqual({
+      kind: "state-degraded",
+      baseStatus: "audit-failed",
+      injectedIssues: ["[warning] 状态结算重试后仍未通过校验。"],
+    });
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: note,
+    }))).toBe("audit-failed");
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: "{bad json",
+      auditIssues: ["[critical] still broken"],
+    }))).toBe("audit-failed");
+
+    expect(resolveStateDegradedBaseStatus(createChapterMeta({
+      reviewNote: "{bad json",
+      auditIssues: ["[warning] needs review"],
+    }))).toBe("ready-for-review");
+  });
+});