novel-writer-cli 0.0.1

package/dist/__tests__/platform-profile.test.js

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { parsePlatformProfile } from "../platform-profile.js";
+function makeBaseRaw() {
+    return {
+        schema_version: 1,
+        platform: "qidian",
+        created_at: "2026-01-01T00:00:00Z",
+        word_count: { target_min: 1, target_max: 2, hard_min: 1, hard_max: 2 },
+        hook_policy: { required: true, min_strength: 3, allowed_types: ["question"], fix_strategy: "hook-fix" },
+        info_load: { max_new_entities_per_chapter: 0, max_unknown_entities_per_chapter: 0, max_new_terms_per_1k_words: 0 },
+        compliance: { banned_words: [], duplicate_name_policy: "warn" },
+        scoring: { genre_drive_type: "plot", weight_profile_id: "plot:v1" }
+    };
+}
+test("parsePlatformProfile loads legacy profile without retention/readability/naming", () => {
+    const raw = makeBaseRaw();
+    const profile = parsePlatformProfile(raw, "platform-profile.json");
+    assert.equal(Object.prototype.hasOwnProperty.call(profile, "retention"), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(profile, "readability"), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(profile, "naming"), false);
+});
+test("parsePlatformProfile accepts explicit null retention/readability/naming", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: null,
+        readability: null,
+        naming: null
+    };
+    const profile = parsePlatformProfile(raw, "platform-profile.json");
+    assert.equal(profile.retention, null);
+    assert.equal(profile.readability, null);
+    assert.equal(profile.naming, null);
+});
+test("parsePlatformProfile loads extended profile with retention/readability/naming", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: { enabled: true, min_chars: 2, max_chars: 30, forbidden_patterns: [], auto_fix: false },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "warn"
+            }
+        },
+        readability: { mobile: { enabled: true, max_paragraph_chars: 320, max_consecutive_exposition_paragraphs: 3, blocking_severity: "hard_only" } },
+        naming: { enabled: true, near_duplicate_threshold: 0.88, blocking_conflict_types: ["duplicate"], exemptions: {} }
+    };
+    const profile = parsePlatformProfile(raw, "platform-profile.json");
+    assert.ok(profile.retention);
+    assert.equal(profile.retention?.hook_ledger.overdue_policy, "warn");
+    assert.equal(profile.readability?.mobile.blocking_severity, "hard_only");
+    assert.deepEqual(profile.naming?.blocking_conflict_types, ["duplicate"]);
+});
+test("parsePlatformProfile rejects unknown naming conflict types", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: 0.5, blocking_conflict_types: ["typo"] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /blocking_conflict_types.*unknown type/i);
+});
+test("parsePlatformProfile rejects naming.near_duplicate_threshold > 1", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: 1.01, blocking_conflict_types: ["near_duplicate"] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /near_duplicate_threshold.*<= 1/i);
+});
+test("parsePlatformProfile rejects naming.near_duplicate_threshold when negative", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: -0.1, blocking_conflict_types: ["near_duplicate"] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /near_duplicate_threshold.*finite number/i);
+});
+test("parsePlatformProfile rejects naming.near_duplicate_threshold when non-finite", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: Number.POSITIVE_INFINITY, blocking_conflict_types: ["near_duplicate"] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /near_duplicate_threshold.*finite number/i);
+});
+test("parsePlatformProfile rejects naming.blocking_conflict_types when contains non-string items", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: 0.5, blocking_conflict_types: [123] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /blocking_conflict_types.*string array/i);
+});
+test("parsePlatformProfile rejects naming.exemptions when non-object", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: true, near_duplicate_threshold: 0.5, blocking_conflict_types: ["duplicate"], exemptions: "foo" }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /exemptions.*object/i);
+});
+test("parsePlatformProfile rejects invalid retention.title_policy regex patterns", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: { enabled: true, min_chars: 2, max_chars: 30, forbidden_patterns: ["("], auto_fix: false },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "warn"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /forbidden_patterns\[0\].*regex/i);
+});
+test("parsePlatformProfile rejects invalid retention.title_policy required_patterns regex patterns", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: {
+                enabled: true,
+                min_chars: 2,
+                max_chars: 30,
+                forbidden_patterns: [],
+                required_patterns: ["("],
+                auto_fix: false
+            },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "warn"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /required_patterns\[0\].*regex/i);
+});
+test("parsePlatformProfile rejects retention.title_policy min_chars > max_chars", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: { enabled: true, min_chars: 10, max_chars: 5, forbidden_patterns: [], auto_fix: false },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "warn"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /min_chars.*<=.*max_chars/i);
+});
+test("parsePlatformProfile rejects retention.title_policy min_chars when float", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: { enabled: true, min_chars: 2.5, max_chars: 30, forbidden_patterns: [], auto_fix: false },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "warn"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /min_chars.*int/i);
+});
+test("parsePlatformProfile rejects retention when non-object", () => {
+    const raw = { ...makeBaseRaw(), retention: 42 };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'retention'.*object/i);
+});
+test("parsePlatformProfile rejects retention.hook_ledger overdue_policy when unknown", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        retention: {
+            title_policy: { enabled: true, min_chars: 2, max_chars: 30, forbidden_patterns: [], auto_fix: false },
+            hook_ledger: {
+                enabled: true,
+                fulfillment_window_chapters: 12,
+                diversity_window_chapters: 5,
+                max_same_type_streak: 2,
+                min_distinct_types_in_window: 2,
+                overdue_policy: "block"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /overdue_policy.*warn, soft, hard/i);
+});
+test("parsePlatformProfile rejects invalid readability.mobile blocking_severity", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        readability: {
+            mobile: {
+                enabled: true,
+                max_paragraph_chars: 320,
+                max_consecutive_exposition_paragraphs: 3,
+                blocking_severity: "warn"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /blocking_severity.*hard_only/i);
+});
+test("parsePlatformProfile rejects readability.mobile max_paragraph_chars = 0", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        readability: {
+            mobile: {
+                enabled: true,
+                max_paragraph_chars: 0,
+                max_consecutive_exposition_paragraphs: 3,
+                blocking_severity: "hard_only"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /max_paragraph_chars.*>= 1/i);
+});
+test("parsePlatformProfile rejects readability.mobile max_consecutive_exposition_paragraphs = 0", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        readability: {
+            mobile: {
+                enabled: true,
+                max_paragraph_chars: 320,
+                max_consecutive_exposition_paragraphs: 0,
+                blocking_severity: "hard_only"
+            }
+        }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /max_consecutive_exposition_paragraphs.*>= 1/i);
+});
+test("parsePlatformProfile rejects non-boolean values for enabled fields", () => {
+    const raw = {
+        ...makeBaseRaw(),
+        naming: { enabled: "true", near_duplicate_threshold: 0.5, blocking_conflict_types: ["duplicate"] }
+    };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'naming\.enabled'.*boolean/i);
+});
+test("parsePlatformProfile rejects readability when non-object", () => {
+    const raw = { ...makeBaseRaw(), readability: 42 };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'readability'.*object/i);
+});
+test("parsePlatformProfile rejects naming when non-object", () => {
+    const raw = { ...makeBaseRaw(), naming: 42 };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'naming'.*object/i);
+});
+test("parsePlatformProfile rejects hook_policy when non-object", () => {
+    const raw = { ...makeBaseRaw(), hook_policy: 42 };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'hook_policy'.*object/i);
+});
+test("parsePlatformProfile rejects scoring when non-object", () => {
+    const raw = { ...makeBaseRaw(), scoring: 42 };
+    assert.throws(() => parsePlatformProfile(raw, "platform-profile.json"), /'scoring'.*object/i);
+});
+test("parsePlatformProfile rejects non-object raw input", () => {
+    assert.throws(() => parsePlatformProfile(null, "platform-profile.json"), /expected a JSON object/i);
+});
+test("templates/platform-profile.json defaults parse as valid platform profiles", async () => {
+    const raw = JSON.parse(await readFile("templates/platform-profile.json", "utf8"));
+    assert.ok(raw.defaults, "expected templates/platform-profile.json to have defaults");
+    for (const [platform, profileRaw] of Object.entries(raw.defaults)) {
+        const profile = parsePlatformProfile(profileRaw, `templates/platform-profile.json#defaults.${platform}`);
+        assert.ok(profile.retention, `expected defaults.${platform}.retention to be present`);
+        assert.ok(profile.readability, `expected defaults.${platform}.readability to be present`);
+        assert.ok(profile.naming, `expected defaults.${platform}.naming to be present`);
+    }
+});

package/dist/__tests__/promise-ledger.test.js

@@ -0,0 +1,189 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { buildPromiseLedgerSeed, computePromiseLedgerReport, loadPromiseLedger, summarizePromiseLedgerReport, writePromiseLedgerLogs } from "../promise-ledger.js";
+async function writeText(absPath, contents) {
+    await mkdir(dirname(absPath), { recursive: true });
+    await writeFile(absPath, contents, "utf8");
+}
+test("loadPromiseLedger returns an empty ledger when promise-ledger.json is missing", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-"));
+    const loaded = await loadPromiseLedger(rootDir);
+    assert.equal(loaded.ledger.schema_version, 1);
+    assert.equal(loaded.ledger.entries.length, 0);
+    assert.equal(loaded.ledger.policy?.dormancy_threshold_chapters, 12);
+});
+test("buildPromiseLedgerSeed extracts candidates from brief/outline/summaries", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-seed-"));
+    await writeText(join(rootDir, "brief.md"), `# Brief\n\n## 卖点\n- 主角每次突破都会引来异象\n\n## 核心谜团\n- 主角身世之谜\n\n## 关系弧\n- 主角与师姐从敌对到信任\n`);
+    await writeText(join(rootDir, "volumes/vol-01/outline.md"), `# 卷大纲\n\n## 机制\n- 系统有代价：使用会消耗寿命\n`);
+    await writeText(join(rootDir, "summaries/chapter-001-summary.md"), `## 第 1 章摘要\n\n### 关键事件\n- 主角触发系统提示，发现寿命消耗\n- 与师姐首次冲突\n`);
+    const seeded = await buildPromiseLedgerSeed({ rootDir, volume: 1, maxRecentSummaries: 5 });
+    assert.ok(seeded.ledger.entries.length >= 4);
+    const texts = seeded.ledger.entries.map((e) => e.promise_text);
+    assert.ok(texts.includes("主角身世之谜"));
+    assert.ok(texts.includes("系统有代价：使用会消耗寿命"));
+    const mystery = seeded.ledger.entries.find((e) => e.promise_text === "主角身世之谜");
+    assert.equal(mystery?.type, "core_mystery");
+    const mechanism = seeded.ledger.entries.find((e) => e.promise_text === "系统有代价：使用会消耗寿命");
+    assert.equal(mechanism?.type, "mechanism");
+});
+test("buildPromiseLedgerSeed avoids overmatching headings and supports uppercase CP", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-seed-headings-"));
+    await writeText(join(rootDir, "brief.md"), `# Brief\n\n## 关键点\n- 主角身世之谜\n\n## CP线\n- 主角与师姐从敌对到信任\n`);
+    const seeded = await buildPromiseLedgerSeed({ rootDir, volume: 1, maxRecentSummaries: 0 });
+    const mystery = seeded.ledger.entries.find((e) => e.promise_text === "主角身世之谜");
+    assert.equal(mystery?.type, "core_mystery");
+    const rel = seeded.ledger.entries.find((e) => e.promise_text === "主角与师姐从敌对到信任");
+    assert.equal(rel?.type, "relationship_arc");
+});
+test("loadPromiseLedger warns and defaults invalid status to promised", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-bad-status-"));
+    await writeText(join(rootDir, "promise-ledger.json"), `${JSON.stringify({
+        schema_version: 1,
+        entries: [
+            {
+                id: "promise:p001",
+                type: "core_mystery",
+                promise_text: "主角身世之谜",
+                status: "oops",
+                introduced_chapter: 1,
+                last_touched_chapter: 1
+            }
+        ]
+    }, null, 2)}\n`);
+    const loaded = await loadPromiseLedger(rootDir);
+    assert.equal(loaded.ledger.entries[0]?.status, "promised");
+    assert.ok(loaded.warnings.some((w) => w.includes("invalid 'status'")));
+});
+test("computePromiseLedgerReport surfaces dormant promises and suggestions", async () => {
+    const ledger = {
+        $schema: "schemas/promise-ledger.schema.json",
+        schema_version: 1,
+        policy: { dormancy_threshold_chapters: 3 },
+        entries: [
+            {
+                id: "promise:p001",
+                type: "core_mystery",
+                promise_text: "主角身世之谜",
+                status: "promised",
+                introduced_chapter: 1,
+                last_touched_chapter: 1
+            },
+            {
+                id: "promise:p002",
+                type: "selling_point",
+                promise_text: "修炼异象机制",
+                status: "advanced",
+                introduced_chapter: 1,
+                last_touched_chapter: 9
+            },
+            {
+                id: "promise:p003",
+                type: "relationship_arc",
+                promise_text: "主角与师姐关系弧",
+                status: "delivered",
+                introduced_chapter: 1,
+                last_touched_chapter: 2,
+                delivered_chapter: 2
+            }
+        ]
+    };
+    const report = computePromiseLedgerReport({ ledger, asOfChapter: 6, volume: 1, chapterRange: { start: 1, end: 6 } });
+    assert.equal(report.schema_version, 1);
+    assert.equal(report.stats.total_promises, 3);
+    assert.equal(report.stats.dormant_total, 1);
+    assert.equal(report.dormant_promises[0]?.id, "promise:p001");
+    assert.ok(report.dormant_promises[0]?.suggestion.length > 0);
+});
+test("writePromiseLedgerLogs keeps latest.json monotonic by chapter (and generated_at tie-break)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-log-mono-"));
+    const mkReport = (chapter, generated_at) => ({
+        schema_version: 1,
+        generated_at,
+        as_of: { chapter, volume: 1 },
+        scope: { volume: 1, chapter_start: Math.max(1, chapter - 9), chapter_end: chapter },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: {
+            total_promises: 0,
+            promised_total: 0,
+            advanced_total: 0,
+            delivered_total: 0,
+            open_total: 0,
+            dormant_total: 0
+        },
+        dormant_promises: [],
+        issues: [],
+        has_blocking_issues: false
+    });
+    await writePromiseLedgerLogs({ rootDir, report: mkReport(5, "2026-01-01T00:00:00.000Z"), historyRange: null });
+    await writePromiseLedgerLogs({ rootDir, report: mkReport(4, "2026-01-02T00:00:00.000Z"), historyRange: null });
+    const latestAbs = join(rootDir, "logs", "promises", "latest.json");
+    const raw = JSON.parse(await readFile(latestAbs, "utf8"));
+    assert.equal(raw.as_of.chapter, 5);
+    await writePromiseLedgerLogs({ rootDir, report: mkReport(5, "2025-01-01T00:00:00.000Z"), historyRange: null });
+    const raw2 = JSON.parse(await readFile(latestAbs, "utf8"));
+    assert.equal(raw2.generated_at, "2026-01-01T00:00:00.000Z");
+    await writePromiseLedgerLogs({ rootDir, report: mkReport(5, "2027-01-01T00:00:00.000Z"), historyRange: null });
+    const raw3 = JSON.parse(await readFile(latestAbs, "utf8"));
+    assert.equal(raw3.generated_at, "2027-01-01T00:00:00.000Z");
+});
+test("writePromiseLedgerLogs writes latest + history when requested", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-promise-ledger-logs-"));
+    const ledger = { $schema: "schemas/promise-ledger.schema.json", schema_version: 1, entries: [] };
+    const report = computePromiseLedgerReport({ ledger, asOfChapter: 10, volume: 2, chapterRange: { start: 1, end: 10 } });
+    const written = await writePromiseLedgerLogs({ rootDir, report, historyRange: { start: 1, end: 10 } });
+    assert.equal(written.latestRel, "logs/promises/latest.json");
+    assert.equal(written.historyRel, "logs/promises/promise-ledger-report-vol-02-ch001-ch010.json");
+    const latestRaw = JSON.parse(await readFile(join(rootDir, written.latestRel), "utf8"));
+    assert.equal(latestRaw.schema_version, 1);
+    const historyRaw = JSON.parse(await readFile(join(rootDir, written.historyRel), "utf8"));
+    assert.equal(historyRaw.schema_version, 1);
+});
+test("summarizePromiseLedgerReport caps lists and truncates surrogate-pair-safe", () => {
+    const longPromiseText = `${"x".repeat(158)}😀${"y".repeat(30)}`;
+    const raw = {
+        schema_version: 1,
+        as_of: { chapter: 10, volume: 1 },
+        scope: { volume: 1, chapter_start: 1, chapter_end: 10 },
+        ledger_path: "promise-ledger.json",
+        policy: { dormancy_threshold_chapters: 12 },
+        stats: {
+            total_promises: 2,
+            promised_total: 2,
+            advanced_total: 0,
+            delivered_total: 0,
+            open_total: 2,
+            dormant_total: 1
+        },
+        dormant_promises: Array.from({ length: 7 }).map((_, i) => ({
+            id: `promise.${i + 1}`,
+            type: "core_mystery",
+            promise_text: i === 0 ? `  ${longPromiseText}  ` : `承诺 ${i + 1}`,
+            status: "promised",
+            chapters_since_last_touch: i,
+            suggestion: "轻触谜团：加入一个微小线索（不要揭示答案）。"
+        })),
+        issues: Array.from({ length: 7 }).map((_, i) => ({
+            id: `promise_ledger.issue.${i + 1}`,
+            severity: "warn",
+            summary: `Issue ${i + 1}`,
+            suggestion: "Keep promises alive with light-touch reminders."
+        })),
+        has_blocking_issues: false
+    };
+    const summary = summarizePromiseLedgerReport(raw);
+    assert.equal(summary.as_of.chapter, 10);
+    assert.equal(summary.stats.total_promises, 2);
+    assert.equal(summary.has_blocking_issues, false);
+    assert.equal(summary.dormant_promises.length, 5);
+    assert.equal(summary.issues.length, 5);
+    const truncated = String(summary.dormant_promises[0]?.promise_text ?? "");
+    assert.ok(truncated.endsWith("…"));
+    const lastBeforeEllipsis = truncated.charCodeAt(Math.max(0, truncated.length - 2));
+    assert.ok(lastBeforeEllipsis < 0xd800 || lastBeforeEllipsis > 0xdbff);
+    assert.equal(summarizePromiseLedgerReport({ schema_version: 2 }), null);
+});