novel-writer-cli 0.1.0 → 0.2.1

package/dist/__tests__/checkpoint-quickstart-phase.test.js

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { readCheckpoint } from "../checkpoint.js";
+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`);
+}
+test("readCheckpoint rejects invalid quickstart_phase string", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-checkpoint-quickstart-phase-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: "banana"
+    });
+    await assert.rejects(() => readCheckpoint(rootDir), /quickstart_phase must be one of:/);
+});
+test("readCheckpoint rejects non-string quickstart_phase", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-checkpoint-quickstart-phase-non-string-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: 42
+    });
+    await assert.rejects(() => readCheckpoint(rootDir), /quickstart_phase must be a string/);
+});
+test("readCheckpoint accepts legacy checkpoint without quickstart_phase", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-checkpoint-quickstart-phase-legacy-missing-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const checkpoint = await readCheckpoint(rootDir);
+    assert.equal(checkpoint.quickstart_phase ?? null, null);
+});

package/dist/__tests__/cli-instructions-novel-ask-gate.test.js

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { main } from "../cli.js";
+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`);
+}
+async function runCli(argv) {
+    let stdout = "";
+    let stderr = "";
+    const origOut = process.stdout.write;
+    const origErr = process.stderr.write;
+    process.stdout.write = (chunk) => {
+        stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    process.stderr.write = (chunk) => {
+        stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    const prevExitCode = process.exitCode;
+    try {
+        const code = await main(argv);
+        return { code, stdout, stderr };
+    }
+    finally {
+        process.exitCode = prevExitCode;
+        process.stdout.write = origOut;
+        process.stderr.write = origErr;
+    }
+}
+test("novel instructions rejects --novel-ask-file without --answer-path (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-novel-ask-missing-answer-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "INIT",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const res = await runCli([
+        "--json",
+        "--project",
+        rootDir,
+        "instructions",
+        "quickstart:world",
+        "--novel-ask-file",
+        "staging/novel-ask/question.json"
+    ]);
+    assert.equal(res.code, 2);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, false);
+    assert.match(payload.error.message, /provide both --novel-ask-file and --answer-path/);
+});
+test("novel instructions rejects --answer-path without --novel-ask-file (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-novel-ask-missing-ask-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "INIT",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const res = await runCli([
+        "--json",
+        "--project",
+        rootDir,
+        "instructions",
+        "quickstart:world",
+        "--answer-path",
+        "staging/novel-ask/answer.json"
+    ]);
+    assert.equal(res.code, 2);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, false);
+    assert.match(payload.error.message, /provide both --novel-ask-file and --answer-path/);
+});

package/dist/__tests__/cli-repair-reset-quickstart.test.js

@@ -0,0 +1,194 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { main } from "../cli.js";
+import { readCheckpoint } from "../checkpoint.js";
+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`);
+}
+async function runCli(argv) {
+    let stdout = "";
+    let stderr = "";
+    const origOut = process.stdout.write;
+    const origErr = process.stderr.write;
+    process.stdout.write = (chunk) => {
+        stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    process.stderr.write = (chunk) => {
+        stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    const prevExitCode = process.exitCode;
+    try {
+        process.exitCode = undefined;
+        const code = await main(argv);
+        return { code, stdout, stderr };
+    }
+    finally {
+        process.exitCode = prevExitCode;
+        process.stdout.write = origOut;
+        process.stderr.write = origErr;
+    }
+}
+test("novel repair previews reset-quickstart without --force (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-preview-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: "characters"
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart"]);
+    assert.equal(res.code, 0);
+    assert.equal(res.stderr, "");
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, true);
+    assert.equal(payload.command, "repair");
+    assert.equal(payload.data.rootDir, rootDir);
+    assert.deepEqual(payload.data.actions, ["reset_quickstart"]);
+    assert.equal(payload.data.applied, false);
+    assert.equal(payload.data.before_present, true);
+    assert.equal(payload.data.after_present, true);
+    assert.equal(payload.data.changed, false);
+    assert.equal(payload.data.would_change, true);
+    assert.equal(payload.data.before, "characters");
+    assert.equal(payload.data.after, "characters");
+    assert.equal(payload.data.target_after, null);
+    const checkpoint = await readCheckpoint(rootDir);
+    assert.equal(checkpoint.quickstart_phase, "characters");
+});
+test("novel repair --reset-quickstart --force sets quickstart_phase=null (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-force-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: "characters"
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart", "--force"]);
+    assert.equal(res.code, 0);
+    assert.equal(res.stderr, "");
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, true);
+    assert.equal(payload.command, "repair");
+    assert.equal(payload.data.rootDir, rootDir);
+    assert.deepEqual(payload.data.actions, ["reset_quickstart"]);
+    assert.equal(payload.data.applied, true);
+    assert.equal(payload.data.before_present, true);
+    assert.equal(payload.data.after_present, true);
+    assert.equal(payload.data.changed, true);
+    assert.equal(payload.data.would_change, true);
+    assert.equal(payload.data.before, "characters");
+    assert.equal(payload.data.after, null);
+    assert.equal(payload.data.target_after, null);
+    const checkpoint = await readCheckpoint(rootDir);
+    assert.equal(checkpoint.quickstart_phase, null);
+    const raw = await readFile(join(rootDir, ".checkpoint.json"), "utf8");
+    assert.match(raw, /\"quickstart_phase\": null/);
+    await assert.rejects(() => stat(join(rootDir, ".novel.lock")), /ENOENT/);
+});
+test("novel repair --reset-quickstart --force normalizes missing quickstart_phase to null (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-missing-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart", "--force"]);
+    assert.equal(res.code, 0);
+    assert.equal(res.stderr, "");
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, true);
+    assert.equal(payload.command, "repair");
+    assert.equal(payload.data.applied, true);
+    assert.equal(payload.data.before_present, false);
+    assert.equal(payload.data.after_present, true);
+    assert.equal(payload.data.changed, true);
+    assert.equal(payload.data.would_change, true);
+    assert.equal(payload.data.before, null);
+    assert.equal(payload.data.after, null);
+    const checkpoint = await readCheckpoint(rootDir);
+    assert.equal(checkpoint.quickstart_phase, null);
+});
+test("novel repair --reset-quickstart --force is idempotent when already null (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-noop-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null,
+        quickstart_phase: null
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart", "--force"]);
+    assert.equal(res.code, 0);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, true);
+    assert.equal(payload.data.applied, true);
+    assert.equal(payload.data.changed, false);
+    assert.equal(payload.data.would_change, false);
+    assert.equal(payload.data.before, null);
+    assert.equal(payload.data.after, null);
+});
+test("novel repair --reset-quickstart fails gracefully when checkpoint missing (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-no-checkpoint-"));
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart", "--force"]);
+    assert.equal(res.code, 2);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, false);
+    assert.equal(payload.command, "repair");
+});
+test("novel repair --reset-quickstart fails gracefully when checkpoint is corrupt JSON (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-corrupt-"));
+    await writeText(join(rootDir, ".checkpoint.json"), "{ broken json !!!}");
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart", "--force"]);
+    assert.ok(res.code !== 0, `expected non-zero exit code, got ${res.code}`);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, false);
+    assert.equal(payload.command, "repair");
+});
+test("novel repair preview reports after_present=true even when field is missing (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-quickstart-preview-missing-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "QUICK_START",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair", "--reset-quickstart"]);
+    assert.equal(res.code, 0);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.data.before_present, false);
+    assert.equal(payload.data.after_present, true);
+    assert.equal(payload.data.would_change, true);
+});
+test("novel repair rejects missing actions (json mode)", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-cli-repair-missing-action-"));
+    await writeJson(join(rootDir, ".checkpoint.json"), {
+        last_completed_chapter: 0,
+        current_volume: 1,
+        orchestrator_state: "INIT",
+        pipeline_stage: null,
+        inflight_chapter: null
+    });
+    const res = await runCli(["--json", "--project", rootDir, "repair"]);
+    assert.equal(res.code, 2);
+    const payload = JSON.parse(res.stdout.trim());
+    assert.equal(payload.ok, false);
+    assert.equal(payload.command, "repair");
+    assert.match(payload.error.message, /no actions specified/i);
+});

package/dist/__tests__/cli-version-flag.test.js

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import test from "node:test";
+import { main } from "../cli.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+async function runCli(argv) {
+    let stdout = "";
+    let stderr = "";
+    const origOut = process.stdout.write;
+    const origErr = process.stderr.write;
+    process.stdout.write = (chunk) => {
+        stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    process.stderr.write = (chunk) => {
+        stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    };
+    const prevExitCode = process.exitCode;
+    try {
+        const code = await main(argv);
+        return { code, stdout, stderr };
+    }
+    finally {
+        process.exitCode = prevExitCode;
+        process.stdout.write = origOut;
+        process.stderr.write = origErr;
+    }
+}
+test("novel --version prints the package version", async () => {
+    const expected = typeof pkg.version === "string" ? pkg.version : null;
+    assert.ok(expected, "Expected package.json to contain a string version.");
+    const res = await runCli(["--version"]);
+    assert.equal(res.code, 0);
+    assert.equal(res.stdout.trim(), expected);
+    assert.equal(res.stderr, "");
+});

package/dist/__tests__/init.test.js

@@ -58,26 +58,28 @@ test("initProject creates a runnable skeleton with all checkpoint fields", async
         assert.equal(result.rootDir, rootDir);
         // Exact created set (non-minimal = checkpoint + 4 templates)
         assert.deepEqual(result.created.sort(), [".checkpoint.json", "ai-blacklist.json", "brief.md", "style-profile.json", "web-novel-cliche-lint.json"].sort());
-        // All 9 staging dirs ensured
-        assert.equal(result.ensuredDirs.length, 9);
+        // All staging dirs ensured
+        assert.equal(result.ensuredDirs.length, 10);
         assert.ok(result.ensuredDirs.includes("staging/chapters"));
         assert.ok(result.ensuredDirs.includes("staging/manifests"));
         assert.ok(result.ensuredDirs.includes("staging/volumes"));
         assert.ok(result.ensuredDirs.includes("staging/foreshadowing"));
+        assert.ok(result.ensuredDirs.includes("staging/quickstart"));
         // Verify ALL checkpoint fields
         const checkpoint = await readCheckpoint(rootDir);
         assert.equal(checkpoint.last_completed_chapter, 0);
         assert.equal(checkpoint.current_volume, 1);
-        assert.equal(checkpoint.pipeline_stage, "committed");
+        assert.equal(checkpoint.orchestrator_state, "INIT");
+        assert.equal(checkpoint.pipeline_stage, null);
         assert.equal(checkpoint.volume_pipeline_stage, null);
         assert.equal(checkpoint.inflight_chapter, null);
         assert.equal(checkpoint.revision_count, 0);
         assert.equal(checkpoint.hook_fix_count, 0);
         assert.equal(checkpoint.title_fix_count, 0);
         assert.ok(typeof checkpoint.last_checkpoint_time === "string" && checkpoint.last_checkpoint_time.length > 0);
-        // Integration: next step should be chapter:001:draft
+        // Integration: next step should be quickstart:world
         const next = await computeNextStep(rootDir, checkpoint);
-        assert.equal(next.step, "chapter:001:draft");
+        assert.equal(next.step, "quickstart:world");
         // All staging dirs exist
         for (const relDir of [
             "staging/chapters",
@@ -88,7 +90,8 @@ test("initProject creates a runnable skeleton with all checkpoint fields", async
             "staging/storylines",
             "staging/volumes",
             "staging/foreshadowing",
-            "staging/manifests"
+            "staging/manifests",
+            "staging/quickstart"
         ]) {
             await assertDir(join(rootDir, relDir));
         }

package/dist/__tests__/instructions-review-novel-ask-gate.test.js

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { buildInstructionPacket } from "../instructions.js";
+test("buildInstructionPacket rejects NOVEL_ASK gate for review steps", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "novel-review-novel-ask-"));
+    const questionSpec = {
+        version: 1,
+        topic: "review_gate",
+        questions: [
+            {
+                id: "ok_to_continue",
+                header: "Continue?",
+                question: "Continue the review pipeline?",
+                kind: "single_choice",
+                required: true,
+                options: [{ label: "yes", description: "Proceed" }]
+            }
+        ]
+    };
+    await assert.rejects(async () => buildInstructionPacket({
+        rootDir,
+        checkpoint: { last_completed_chapter: 0, current_volume: 1, orchestrator_state: "VOL_REVIEW" },
+        step: { kind: "review", phase: "collect" },
+        embedMode: null,
+        writeManifest: false,
+        novelAskGate: { novel_ask: questionSpec, answer_path: "staging/novel-ask/review.json" }
+    }), /NOVEL_ASK gate is not supported for review steps/);
+});

package/dist/__tests__/orchestrator-state-routing.test.js

@@ -62,15 +62,17 @@ test("readCheckpoint rejects inflight_chapter=0", async () => {
     });
     await assert.rejects(() => readCheckpoint(rootDir), /inflight_chapter must be an int >= 1/);
 });
-test("computeNextStep throws for INIT placeholder", async () => {
+test("computeNextStep routes INIT to quickstart pipeline", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-orchestrator-init-"));
-    await assert.rejects(() => computeNextStep(rootDir, {
+    const next = await computeNextStep(rootDir, {
         last_completed_chapter: 0,
         current_volume: 1,
         orchestrator_state: "INIT",
         pipeline_stage: null,
         inflight_chapter: null
-    }), /Not implemented: orchestrator_state=INIT/);
+    });
+    assert.equal(next.step, "quickstart:world");
+    assert.equal(next.reason, "init:quickstart:world");
 });
 test("computeNextStep throws when pipeline_stage=committed but inflight_chapter is set", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-orchestrator-committed-inflight-"));
@@ -82,15 +84,17 @@ test("computeNextStep throws when pipeline_stage=committed but inflight_chapter
         inflight_chapter: 7
     }), /Checkpoint inconsistent: pipeline_stage=committed but inflight_chapter=7/);
 });
-test("computeNextStep throws for QUICK_START placeholder", async () => {
+test("computeNextStep routes QUICK_START to quickstart pipeline", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-orchestrator-quickstart-"));
-    await assert.rejects(() => computeNextStep(rootDir, {
+    const next = await computeNextStep(rootDir, {
         last_completed_chapter: 0,
         current_volume: 1,
         orchestrator_state: "QUICK_START",
         pipeline_stage: null,
         inflight_chapter: null
-    }), /Not implemented: orchestrator_state=QUICK_START/);
+    });
+    assert.equal(next.step, "quickstart:world");
+    assert.equal(next.reason, "quickstart:world");
 });
 test("computeNextStep prefixes reason for ERROR_RETRY", async () => {
     const rootDir = await mkdtemp(join(tmpdir(), "novel-orchestrator-error-retry-"));