novel-writer-cli 0.3.0 → 0.5.0

package/dist/__tests__/excitement-type-annotation.test.js

@@ -0,0 +1,240 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { buildInstructionPacket } from "../instructions.js";
+import { validateStep } from "../validate.js";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+async function readRepoText(relPath) {
+    return readFile(join(repoRoot, relPath), "utf8");
+}
+async function writeText(absPath, contents) {
+    await mkdir(dirname(absPath), { recursive: true });
+    await writeFile(absPath, contents, "utf8");
+}
+async function writeJson(absPath, payload) {
+    await writeText(absPath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+function makeJudgeCheckpoint(chapter) {
+    return {
+        last_completed_chapter: chapter - 1,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "refined",
+        inflight_chapter: chapter,
+        revision_count: 0,
+        hook_fix_count: 0,
+        title_fix_count: 0
+    };
+}
+function makeDraftCheckpoint(chapter) {
+    return {
+        last_completed_chapter: chapter - 1,
+        current_volume: 1,
+        orchestrator_state: "WRITING",
+        pipeline_stage: "committed",
+        inflight_chapter: chapter,
+        revision_count: 0,
+        hook_fix_count: 0,
+        title_fix_count: 0
+    };
+}
+function makeVolumeCheckpoint() {
+    return {
+        last_completed_chapter: 58,
+        current_volume: 2,
+        orchestrator_state: "VOL_PLANNING",
+        pipeline_stage: null,
+        volume_pipeline_stage: null,
+        inflight_chapter: null,
+        revision_count: 0,
+        hook_fix_count: 0,
+        title_fix_count: 0
+    };
+}
+test("issue 129 prompts and skills describe excitement_type flow", async () => {
+    const plotArchitect = await readRepoText("agents/plot-architect.md");
+    const qualityJudge = await readRepoText("agents/quality-judge.md");
+    const continueSkill = await readRepoText("skills/continue/SKILL.md");
+    const volumePlanning = await readRepoText("skills/start/references/vol-planning.md");
+    assert.match(plotArchitect, /excitement_type/);
+    assert.match(plotArchitect, /\*\*ExcitementType\*\*/);
+    assert.match(qualityJudge, /excitement_type/);
+    assert.match(qualityJudge, /excitement_landing/);
+    assert.match(qualityJudge, /铺垫有效性/);
+    assert.match(continueSkill, /packet\.manifest\.inline\.excitement_type/);
+    assert.match(volumePlanning, /ExcitementType/);
+    assert.match(volumePlanning, /未知值仅警告并按 `null` 处理/);
+});
+test("buildInstructionPacket injects excitement_type for judge packets with contract-first fallback", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-excitement-packet-"));
+    try {
+        await writeText(join(rootDir, "volumes/vol-01/outline.md"), [
+            "## 第 1 卷大纲",
+            "",
+            "### 第 1 章: 测试",
+            "- **Storyline**: main-arc",
+            "- **POV**: hero",
+            "- **Location**: city",
+            "- **Conflict**: test",
+            "- **Arc**: test",
+            "- **Foreshadowing**: test",
+            "- **StateChanges**: test",
+            "- **TransitionHint**: {}",
+            "- **ExcitementType**: face_slap",
+            ""
+        ].join("\n"));
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        await writeText(join(rootDir, "staging/chapters/chapter-001.md"), "# 第1章\n\n正文\n");
+        const fromOutline = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeJudgeCheckpoint(1),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(fromOutline.packet.manifest.inline.excitement_type, "face_slap");
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            excitement_type: "setup",
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        const fromContract = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeJudgeCheckpoint(1),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(fromContract.packet.manifest.inline.excitement_type, "setup");
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            excitement_type: "boom",
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        const unknownContract = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeJudgeCheckpoint(1),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(unknownContract.packet.manifest.inline.excitement_type, null);
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            excitement_type: null,
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        const explicitNull = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeJudgeCheckpoint(1),
+            step: { kind: "chapter", chapter: 1, stage: "judge" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(explicitNull.packet.manifest.inline.excitement_type, null);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("buildInstructionPacket does not inject excitement_type for non-judge packets", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-excitement-draft-packet-"));
+    try {
+        await writeText(join(rootDir, "volumes/vol-01/outline.md"), [
+            "## 第 1 卷大纲",
+            "",
+            "### 第 1 章: 测试",
+            "- **Storyline**: main-arc",
+            "- **POV**: hero",
+            "- **Location**: city",
+            "- **Conflict**: test",
+            "- **Arc**: test",
+            "- **Foreshadowing**: test",
+            "- **StateChanges**: test",
+            "- **TransitionHint**: {}",
+            "- **ExcitementType**: face_slap",
+            ""
+        ].join("\n"));
+        await writeJson(join(rootDir, "volumes/vol-01/chapter-contracts/chapter-001.json"), {
+            chapter: 1,
+            storyline_id: "main-arc",
+            excitement_type: "face_slap",
+            objectives: [{ id: "OBJ-1", required: true, description: "x" }]
+        });
+        const packet = (await buildInstructionPacket({
+            rootDir,
+            checkpoint: makeDraftCheckpoint(1),
+            step: { kind: "chapter", chapter: 1, stage: "draft" },
+            embedMode: null,
+            writeManifest: false
+        }));
+        assert.equal(Object.prototype.hasOwnProperty.call(packet.packet.manifest.inline, "excitement_type"), false);
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});
+test("validateStep(volume:outline) warns for missing or unknown excitement_type without blocking", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-excitement-validate-"));
+    try {
+        await writeText(join(rootDir, "staging/volumes/vol-02/outline.md"), [
+            "## 第 2 卷大纲",
+            "",
+            "### 第59章: 测试",
+            "- **Storyline**: main-arc",
+            "- **POV**: hero",
+            "- **Location**: city",
+            "- **Conflict**: test",
+            "- **Arc**: test",
+            "- **Foreshadowing**: test",
+            "- **StateChanges**: test",
+            "- **TransitionHint**: {}",
+            "- **ExcitementType**: setup",
+            "",
+            "### 第60章: 测试",
+            "- **Storyline**: main-arc",
+            "- **POV**: hero",
+            "- **Location**: city",
+            "- **Conflict**: test",
+            "- **Arc**: test",
+            "- **Foreshadowing**: test",
+            "- **StateChanges**: test",
+            "- **TransitionHint**: {}",
+            "- **ExcitementType**: galaxy_brain",
+            ""
+        ].join("\n"));
+        await writeJson(join(rootDir, "staging/volumes/vol-02/storyline-schedule.json"), { active_storylines: ["main-arc"] });
+        await writeJson(join(rootDir, "staging/volumes/vol-02/foreshadowing.json"), { schema_version: 1, items: [] });
+        await writeJson(join(rootDir, "staging/volumes/vol-02/new-characters.json"), []);
+        const contractBase = {
+            storyline_id: "main-arc",
+            objectives: [{ id: "OBJ", required: true, description: "x" }],
+            preconditions: { character_states: { Alice: { location: "city" } } },
+            postconditions: { state_changes: {} }
+        };
+        await writeJson(join(rootDir, "staging/volumes/vol-02/chapter-contracts/chapter-059.json"), { chapter: 59, ...contractBase });
+        await writeJson(join(rootDir, "staging/volumes/vol-02/chapter-contracts/chapter-060.json"), {
+            chapter: 60,
+            excitement_type: "boom",
+            ...contractBase
+        });
+        const report = await validateStep({ rootDir, checkpoint: makeVolumeCheckpoint(), step: { kind: "volume", phase: "outline" } });
+        assert.equal(report.ok, true);
+        assert.ok(report.warnings.some((w) => w.includes("chapter 60") && w.includes("ExcitementType") && w.includes("galaxy_brain")));
+        assert.ok(report.warnings.some((w) => w.includes("chapter-059.json") && w.includes("Missing optional excitement_type")));
+        assert.ok(report.warnings.some((w) => w.includes("chapter-060.json") && w.includes("boom")));
+    }
+    finally {
+        await rm(rootDir, { recursive: true, force: true });
+    }
+});

package/dist/__tests__/excitement-type.test.js

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { EXCITEMENT_TYPES, normalizeExcitementType } from "../excitement-type.js";
+test("normalizeExcitementType accepts every supported enum value", () => {
+    for (const value of EXCITEMENT_TYPES) {
+        assert.equal(normalizeExcitementType(value), value);
+    }
+});
+test("normalizeExcitementType treats blank and null-like inputs as null", () => {
+    assert.equal(normalizeExcitementType(""), null);
+    assert.equal(normalizeExcitementType("  "), null);
+    assert.equal(normalizeExcitementType("null"), null);
+    assert.equal(normalizeExcitementType(null), null);
+    assert.equal(normalizeExcitementType(undefined), null);
+});
+test("normalizeExcitementType returns undefined for unsupported non-string or unknown values", () => {
+    assert.equal(normalizeExcitementType(true), undefined);
+    assert.equal(normalizeExcitementType(42), undefined);
+    assert.equal(normalizeExcitementType({ value: "setup" }), undefined);
+    assert.equal(normalizeExcitementType("galaxy_brain"), undefined);
+});

package/dist/__tests__/gate-decision.test.js

@@ -1,33 +1,36 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { computeGateDecision, detectHighConfidenceViolation } from "../gate-decision.js";
+import { computeGateDecision, detectGoldenChapterGateFailure, detectHighConfidenceViolation, evaluateGateDecisionFromEval } from "../gate-decision.js";
 test("computeGateDecision maps score bands to decisions (no violations)", () => {
-    assert.equal(computeGateDecision({ overall_final: 4.0, revision_count: 0, has_high_confidence_violation: false }), "pass");
-    assert.equal(computeGateDecision({ overall_final: 3.9, revision_count: 0, has_high_confidence_violation: false }), "polish");
-    assert.equal(computeGateDecision({ overall_final: 3.5, revision_count: 0, has_high_confidence_violation: false }), "polish");
-    assert.equal(computeGateDecision({ overall_final: 3.4, revision_count: 0, has_high_confidence_violation: false }), "revise");
-    assert.equal(computeGateDecision({ overall_final: 3.0, revision_count: 0, has_high_confidence_violation: false }), "revise");
-    assert.equal(computeGateDecision({ overall_final: 2.9, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user");
-    assert.equal(computeGateDecision({ overall_final: 2.0, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user");
-    assert.equal(computeGateDecision({ overall_final: 1.99, revision_count: 0, has_high_confidence_violation: false }), "pause_for_user_force_rewrite");
+    assert.equal(computeGateDecision({ overall_final: 4.0, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "pass");
+    assert.equal(computeGateDecision({ overall_final: 3.9, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "polish");
+    assert.equal(computeGateDecision({ overall_final: 3.5, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "polish");
+    assert.equal(computeGateDecision({ overall_final: 3.4, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "revise");
+    assert.equal(computeGateDecision({ overall_final: 3.0, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "revise");
+    assert.equal(computeGateDecision({ overall_final: 2.9, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "pause_for_user");
+    assert.equal(computeGateDecision({ overall_final: 2.0, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "pause_for_user");
+    assert.equal(computeGateDecision({ overall_final: 1.99, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "pause_for_user_force_rewrite");
 });
 test("computeGateDecision forces revise on high-confidence violations", () => {
-    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 0, has_high_confidence_violation: true }), "revise");
+    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 0, has_high_confidence_violation: true, has_golden_chapter_gate_failure: false }), "revise");
 });
 test("computeGateDecision pauses for user when high-confidence violations persist beyond max_revisions", () => {
-    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 2, has_high_confidence_violation: true }), "pause_for_user");
+    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 2, has_high_confidence_violation: true, has_golden_chapter_gate_failure: false }), "pause_for_user");
+});
+test("computeGateDecision forces revise on golden chapter gate failures", () => {
+    assert.equal(computeGateDecision({ overall_final: 4.8, revision_count: 0, has_high_confidence_violation: false, has_golden_chapter_gate_failure: true }), "revise");
 });
 test("computeGateDecision allows force_passed when revisions exhausted and score >= 3.0", () => {
-    assert.equal(computeGateDecision({ overall_final: 3.2, revision_count: 2, has_high_confidence_violation: false }), "force_passed");
+    assert.equal(computeGateDecision({ overall_final: 3.2, revision_count: 2, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "force_passed");
 });
 test("computeGateDecision force-passes polish band when revisions exhausted", () => {
-    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 2, has_high_confidence_violation: false }), "force_passed");
+    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 2, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false }), "force_passed");
 });
 test("computeGateDecision respects max_revisions override", () => {
-    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 1, has_high_confidence_violation: false, max_revisions: 1 }), "force_passed");
+    assert.equal(computeGateDecision({ overall_final: 3.6, revision_count: 1, has_high_confidence_violation: false, has_golden_chapter_gate_failure: false, max_revisions: 1 }), "force_passed");
 });
 test("computeGateDecision supports manual force_pass override", () => {
-    assert.equal(computeGateDecision({ overall_final: 1.0, revision_count: 0, has_high_confidence_violation: true, force_pass: true }), "force_passed");
+    assert.equal(computeGateDecision({ overall_final: 1.0, revision_count: 0, has_high_confidence_violation: true, has_golden_chapter_gate_failure: true, force_pass: true }), "force_passed");
 });
 test("detectHighConfidenceViolation returns false when contract_verification is missing", () => {
     assert.deepEqual(detectHighConfidenceViolation({ overall: 4.0, recommendation: "pass" }), {
@@ -64,3 +67,47 @@ test("detectHighConfidenceViolation marks inferred constraint_type for ls_checks
     assert.equal(res.high_confidence_violations.length, 1);
     assert.equal(res.high_confidence_violations[0].constraint_type_inferred, true);
 });
+test("detectGoldenChapterGateFailure returns false when gates are missing", () => {
+    assert.deepEqual(detectGoldenChapterGateFailure({ overall: 4.0, recommendation: "pass" }), {
+        has_golden_chapter_gate_failure: false,
+        failed_checks: []
+    });
+});
+test("detectGoldenChapterGateFailure deduplicates repeated failed gate ids", () => {
+    const res = detectGoldenChapterGateFailure({
+        golden_chapter_gates: {
+            activated: true,
+            passed: false,
+            failed_gate_ids: ["hook_present", "protagonist_within_200_words"],
+            checks: [{ id: "hook_present", status: "fail", detail: "no hook" }]
+        }
+    });
+    assert.equal(res.has_golden_chapter_gate_failure, true);
+    assert.equal(res.failed_checks.length, 2);
+    assert.deepEqual(res.failed_checks.map((item) => item.id), ["hook_present", "protagonist_within_200_words"]);
+});
+test("detectGoldenChapterGateFailure accepts failed and violation statuses", () => {
+    const res = detectGoldenChapterGateFailure({
+        golden_chapter_gates: {
+            activated: true,
+            checks: [
+                { id: "a", status: "failed" },
+                { id: "b", status: "violation" }
+            ]
+        }
+    });
+    assert.equal(res.has_golden_chapter_gate_failure, true);
+    assert.deepEqual(res.failed_checks.map((item) => item.id), ["a", "b"]);
+});
+test("evaluateGateDecisionFromEval rejects non-object eval payloads", () => {
+    assert.deepEqual(evaluateGateDecisionFromEval({ evalRaw: null, revision_count: 0 }), {
+        ok: false,
+        reason: "eval_invalid"
+    });
+});
+test("evaluateGateDecisionFromEval rejects missing overall scores", () => {
+    assert.deepEqual(evaluateGateDecisionFromEval({ evalRaw: { chapter: 1 }, revision_count: 0 }), {
+        ok: false,
+        reason: "eval_missing_overall"
+    });
+});