novel-writer-cli 0.3.0 → 0.5.0

package/dist/next-step.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { tryResolveVolumeChapterRange } from "./consistency-auditor.js";
 import { NovelCliError } from "./errors.js";
 import { pathExists, readJsonFile, readTextFile } from "./fs-utils.js";
-import { computeGateDecision, detectHighConfidenceViolation } from "./gate-decision.js";
+import { evaluateGateDecisionFromEval, normalizeGateMaxRevisions, normalizeGateRevisionCount } from "./gate-decision.js";
 import { checkHookPolicy } from "./hook-policy.js";
 import { loadPlatformProfile } from "./platform-profile.js";
 import { QUICKSTART_STAGING_RELS } from "./quickstart.js";
@@ -15,7 +15,84 @@ import { summarizeReadabilityIssues } from "./readability-lint.js";
 import { computeTitlePolicyReport } from "./title-policy.js";
 import { QUICKSTART_PHASES, chapterRelPaths, formatStepId } from "./steps.js";
 import { isPlainObject } from "./type-guards.js";
-import { computeVolumeNextStep } from "./volume-planning.js";
+import { computeVolumeNextStep, hasQuickstartMiniPlanningArtifacts, volumeFinalRelPaths } from "./volume-planning.js";
+function resolveMaxRevisions(loadedProfile) {
+    return normalizeGateMaxRevisions(loadedProfile?.profile.scoring?.max_revisions);
+}
+function routeGateDrivenNextStep(args) {
+    const evaluated = evaluateGateDecisionFromEval({
+        evalRaw: args.evalRaw,
+        revision_count: args.revisionCount,
+        ...(args.maxRevisions === null ? {} : { max_revisions: args.maxRevisions })
+    });
+    if (!evaluated.ok) {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "judge" }),
+            reason: `${args.stagePrefix}:${evaluated.reason}`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: { ...args.evidence }
+        };
+    }
+    const gate = evaluated.gate;
+    const gateEvidence = {
+        ...args.evidence,
+        gate: {
+            decision: gate.decision,
+            overall_final: gate.overall_final,
+            revision_count: gate.revision_count,
+            max_revisions: gate.max_revisions,
+            has_high_confidence_violation: gate.has_high_confidence_violation,
+            high_confidence_violations: gate.high_confidence_violations.slice(0, 10),
+            has_golden_chapter_gate_failure: gate.has_golden_chapter_gate_failure,
+            golden_chapter_gate_failures: gate.golden_chapter_gate_failures.slice(0, 10)
+        },
+        quality_judge: {
+            recommendation: gate.recommendation
+        }
+    };
+    if (gate.decision === "pass") {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "commit" }),
+            reason: `${args.stagePrefix}:gate:pass`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: gateEvidence
+        };
+    }
+    if (gate.decision === "force_passed") {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "commit" }),
+            reason: `${args.stagePrefix}:gate:force_passed`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: gateEvidence
+        };
+    }
+    if (gate.decision === "polish") {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "refine" }),
+            reason: `${args.stagePrefix}:gate:polish`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: gateEvidence
+        };
+    }
+    if (gate.decision === "revise") {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "draft" }),
+            reason: `${args.stagePrefix}:gate:revise`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: gateEvidence
+        };
+    }
+    if (gate.decision === "pause_for_user" || gate.decision === "pause_for_user_force_rewrite") {
+        return {
+            step: formatStepId({ kind: "chapter", chapter: args.inflightChapter, stage: "review" }),
+            reason: `${args.stagePrefix}:gate:${gate.decision}`,
+            inflight: { chapter: args.inflightChapter, pipeline_stage: args.pipelineStage },
+            evidence: gateEvidence
+        };
+    }
+    const _exhaustive = gate.decision;
+    throw new NovelCliError(`Unsupported gate decision: ${String(_exhaustive)}`, 2);
+}
 function normalizeStage(stage) {
     if (stage === null || stage === undefined)
         return null;
@@ -368,12 +445,29 @@ async function computeChapterNextStep(projectRootDir, checkpoint) {
         });
         if (guardrailsGate)
             return guardrailsGate;
-        return {
-            step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "commit" }),
-            reason: "refined:ready_commit",
-            inflight: { chapter: inflightChapter, pipeline_stage: stage },
-            evidence
-        };
+        let evalRaw;
+        try {
+            evalRaw = await readJsonFile(join(projectRootDir, rel.staging.evalJson));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "judge" }),
+                reason: "refined:eval_read_failed",
+                inflight: { chapter: inflightChapter, pipeline_stage: stage },
+                evidence: { ...evidence, error: message }
+            };
+        }
+        const revisionCount = normalizeGateRevisionCount(checkpoint.revision_count);
+        return routeGateDrivenNextStep({
+            stagePrefix: "refined",
+            inflightChapter,
+            pipelineStage: stage,
+            evidence,
+            evalRaw,
+            revisionCount,
+            maxRevisions: resolveMaxRevisions(loadedProfile)
+        });
     }
     if (stage === "judged") {
         if (!hasChapter) {
@@ -451,87 +545,16 @@ async function computeChapterNextStep(projectRootDir, checkpoint) {
                 evidence: { ...evidence }
             };
         }
-        const evalObj = evalRaw;
-        const overall = typeof evalObj.overall_final === "number" ? evalObj.overall_final : typeof evalObj.overall === "number" ? evalObj.overall : null;
-        if (overall === null || !Number.isFinite(overall)) {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "judge" }),
-                reason: `judged:eval_missing_overall`,
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: { ...evidence }
-            };
-        }
-        const revisionCount = typeof checkpoint.revision_count === "number" && Number.isInteger(checkpoint.revision_count) && checkpoint.revision_count >= 0
-            ? checkpoint.revision_count
-            : 0;
-        const violation = detectHighConfidenceViolation(evalRaw);
-        const maxRevisions = typeof loadedProfile?.profile.scoring?.max_revisions === "number" &&
-            Number.isInteger(loadedProfile.profile.scoring.max_revisions) &&
-            loadedProfile.profile.scoring.max_revisions >= 0
-            ? loadedProfile.profile.scoring.max_revisions
-            : null;
-        const gateDecision = computeGateDecision({
-            overall_final: overall,
-            revision_count: revisionCount,
-            has_high_confidence_violation: violation.has_high_confidence_violation,
-            ...(maxRevisions === null ? {} : { max_revisions: maxRevisions })
+        const revisionCount = normalizeGateRevisionCount(checkpoint.revision_count);
+        return routeGateDrivenNextStep({
+            stagePrefix: "judged",
+            inflightChapter,
+            pipelineStage: stage,
+            evidence,
+            evalRaw,
+            revisionCount,
+            maxRevisions: resolveMaxRevisions(loadedProfile)
         });
-        const gateEvidence = {
-            ...evidence,
-            gate: {
-                decision: gateDecision,
-                overall_final: overall,
-                revision_count: revisionCount,
-                max_revisions: maxRevisions,
-                has_high_confidence_violation: violation.has_high_confidence_violation,
-                high_confidence_violations: violation.high_confidence_violations.slice(0, 10)
-            },
-            quality_judge: {
-                recommendation: typeof evalObj.recommendation === "string" ? evalObj.recommendation : null
-            }
-        };
-        if (gateDecision === "pass") {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "commit" }),
-                reason: "judged:gate:pass",
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: gateEvidence
-            };
-        }
-        if (gateDecision === "force_passed") {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "commit" }),
-                reason: "judged:gate:force_passed",
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: gateEvidence
-            };
-        }
-        if (gateDecision === "polish") {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "refine" }),
-                reason: "judged:gate:polish",
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: gateEvidence
-            };
-        }
-        if (gateDecision === "revise") {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "draft" }),
-                reason: "judged:gate:revise",
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: gateEvidence
-            };
-        }
-        if (gateDecision === "pause_for_user" || gateDecision === "pause_for_user_force_rewrite") {
-            return {
-                step: formatStepId({ kind: "chapter", chapter: inflightChapter, stage: "review" }),
-                reason: `judged:gate:${gateDecision}`,
-                inflight: { chapter: inflightChapter, pipeline_stage: stage },
-                evidence: gateEvidence
-            };
-        }
-        const _exhaustive = gateDecision;
-        throw new NovelCliError(`Unsupported gate decision: ${String(_exhaustive)}`, 2);
     }
     // Unknown stage: upstream parseCheckpoint validates enum so this should be unreachable.
     throw new NovelCliError(`Checkpoint has unexpected pipeline_stage=${stage}. This should not happen; repair .checkpoint.json and rerun.`, 2);
@@ -576,6 +599,7 @@ async function computeQuickStartNextStep(projectRootDir, checkpoint) {
     const rulesExists = await pathExists(rulesAbs);
     const contracts = await countContractArtifacts(projectRootDir);
     const styleExists = await pathExists(styleAbs);
+    const miniPlanningExists = await hasQuickstartMiniPlanningArtifacts(projectRootDir);
     const trialExists = await pathExists(trialAbs);
     const evalExists = await pathExists(evalAbs);
     let rulesOk = false;
@@ -648,6 +672,7 @@ async function computeQuickStartNextStep(projectRootDir, checkpoint) {
             styleExists,
             styleOk,
             ...(styleError ? { styleError } : {}),
+            miniPlanningExists,
             trialExists,
             trialOk,
             ...(trialError ? { trialError } : {}),
@@ -685,6 +710,15 @@ async function computeQuickStartNextStep(projectRootDir, checkpoint) {
             evidence
         };
     }
+    else if (!miniPlanningExists) {
+        selectedPhase = "f0";
+        selected = {
+            step: formatStepId({ kind: "quickstart", phase: "f0" }),
+            reason: "quickstart:f0",
+            inflight: { chapter: null, pipeline_stage: null },
+            evidence
+        };
+    }
     else if (!trialOk) {
         selectedPhase = "trial";
         selected = {
@@ -728,6 +762,8 @@ async function computeQuickStartNextStep(projectRootDir, checkpoint) {
                         return QUICKSTART_STAGING_RELS.contractsDir;
                     case "style":
                         return QUICKSTART_STAGING_RELS.styleProfileJson;
+                    case "f0":
+                        return volumeFinalRelPaths(1).outlineMd;
                     case "trial":
                         return QUICKSTART_STAGING_RELS.trialChapterMd;
                     case "results":

package/dist/platform-profile.js

@@ -2,6 +2,8 @@ import { join } from "node:path";
 import { NovelCliError } from "./errors.js";
 import { pathExists, readJsonFile } from "./fs-utils.js";
 import { isPlainObject } from "./type-guards.js";
+export const PLATFORM_IDS = ["qidian", "tomato", "fanqie", "jinjiang"];
+export const CANONICAL_PLATFORM_IDS = ["qidian", "fanqie", "jinjiang"];
 function requireIntField(obj, field, file) {
     const v = obj[field];
     if (typeof v !== "number" || !Number.isInteger(v))
@@ -33,9 +35,14 @@ function requireStringField(obj, field, file) {
     return v;
 }
 function requirePlatformId(value, file) {
-    if (value === "qidian" || value === "tomato")
+    if (value === "qidian" || value === "tomato" || value === "fanqie" || value === "jinjiang")
         return value;
-    throw new NovelCliError(`Invalid ${file}: 'platform' must be one of: qidian, tomato.`, 2);
+    throw new NovelCliError(`Invalid ${file}: 'platform' must be one of: ${PLATFORM_IDS.join(", ")}.`, 2);
+}
+export function canonicalPlatformId(id) {
+    if (id === "tomato")
+        return "fanqie";
+    return id;
 }
 function requireSeverityPolicy(value, file, field) {
     if (value === "warn" || value === "soft" || value === "hard")
@@ -46,12 +53,17 @@ function parseWordCountPolicy(raw, file) {
     if (!isPlainObject(raw))
         throw new NovelCliError(`Invalid ${file}: 'word_count' must be an object.`, 2);
     const obj = raw;
-    return {
-        target_min: requireIntField(obj, "target_min", file),
-        target_max: requireIntField(obj, "target_max", file),
-        hard_min: requireIntField(obj, "hard_min", file),
-        hard_max: requireIntField(obj, "hard_max", file)
-    };
+    const target_min = requireIntField(obj, "target_min", file);
+    const target_max = requireIntField(obj, "target_max", file);
+    const hard_min = requireIntField(obj, "hard_min", file);
+    const hard_max = requireIntField(obj, "hard_max", file);
+    if (target_min > target_max) {
+        throw new NovelCliError(`Invalid ${file}: 'word_count.target_min' must be <= 'word_count.target_max'.`, 2);
+    }
+    if (hard_min > hard_max) {
+        throw new NovelCliError(`Invalid ${file}: 'word_count.hard_min' must be <= 'word_count.hard_max'.`, 2);
+    }
+    return { target_min, target_max, hard_min, hard_max };
 }
 function parseInfoLoadPolicy(raw, file) {
     if (!isPlainObject(raw))

package/dist/quickstart-mini-planning.js

@@ -0,0 +1,30 @@
+export const QUICKSTART_MINI_PLANNING_RANGE = { start: 1, end: 3 };
+export function quickstartMiniPlanningChapters(range = QUICKSTART_MINI_PLANNING_RANGE) {
+    const chapters = [];
+    for (let chapter = range.start; chapter <= range.end; chapter++) {
+        chapters.push(chapter);
+    }
+    return chapters;
+}
+export function extractOutlineChapterNumbers(text) {
+    const chapterHeadingRe = /^###\s*第\s*(\d+)\s*章/u;
+    const chapters = [];
+    for (const line of text.split(/\r?\n/u)) {
+        const match = chapterHeadingRe.exec(line);
+        if (!match)
+            continue;
+        const chapter = Number.parseInt(match[1] ?? "", 10);
+        if (!Number.isInteger(chapter) || chapter < 1)
+            continue;
+        chapters.push(chapter);
+    }
+    return chapters;
+}
+export function matchesQuickstartMiniPlanningSeedSequence(chapters) {
+    const expectedChapters = quickstartMiniPlanningChapters();
+    return chapters.length === expectedChapters.length && chapters.every((chapter, index) => chapter === expectedChapters[index]);
+}
+export function startsWithQuickstartMiniPlanningSeedSequence(chapters) {
+    const expectedChapters = quickstartMiniPlanningChapters();
+    return chapters.length >= expectedChapters.length && expectedChapters.every((chapter, index) => chapters[index] === chapter);
+}

package/dist/scoring-weights.js

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { NovelCliError } from "./errors.js";
 import { pathExists, readJsonFile, writeJsonFile } from "./fs-utils.js";
+import { CANONICAL_PLATFORM_IDS, canonicalPlatformId } from "./platform-profile.js";
 import { isPlainObject } from "./type-guards.js";
 const CORE_DIMENSIONS = [
     "plot_logic",
@@ -13,7 +14,11 @@ const CORE_DIMENSIONS = [
     "storyline_coherence",
 ];
 const OPTIONAL_DIMENSIONS = ["hook_strength"];
-const KNOWN_DIMENSIONS = new Set([...CORE_DIMENSIONS, ...OPTIONAL_DIMENSIONS]);
+export const KNOWN_SCORING_DIMENSIONS = [...CORE_DIMENSIONS, ...OPTIONAL_DIMENSIONS];
+const KNOWN_DIMENSIONS = new Set(KNOWN_SCORING_DIMENSIONS);
+export function isKnownScoringDimension(value) {
+    return KNOWN_DIMENSIONS.has(value);
+}
 function requireIntField(obj, field, file) {
     const v = obj[field];
     if (typeof v !== "number" || !Number.isInteger(v))
@@ -90,6 +95,7 @@ export function parseGenreWeightProfiles(raw, file) {
         throw new NovelCliError(`Invalid ${file}: 'profiles' must be an object.`, 2);
     const profilesRaw = obj.profiles;
     const profiles = {};
+    const canonicalPlatforms = new Set(CANONICAL_PLATFORM_IDS);
     const allowedDims = new Set(dimensions);
     for (const [profileId, profileRaw] of Object.entries(profilesRaw)) {
         if (!isPlainObject(profileRaw))
@@ -129,6 +135,31 @@ export function parseGenreWeightProfiles(raw, file) {
         default_profile_by_drive_type,
         profiles
     };
+    if (obj.platform_multipliers !== undefined) {
+        if (!isPlainObject(obj.platform_multipliers)) {
+            throw new NovelCliError(`Invalid ${file}: 'platform_multipliers' must be an object.`, 2);
+        }
+        const multipliersRaw = obj.platform_multipliers;
+        const platform_multipliers = {};
+        for (const [platformId, platformRaw] of Object.entries(multipliersRaw)) {
+            if (!canonicalPlatforms.has(platformId)) {
+                throw new NovelCliError(`Invalid ${file}: unknown platform_multipliers key '${platformId}' (allowed canonical ids: ${CANONICAL_PLATFORM_IDS.join(", ")}).`, 2);
+            }
+            if (!isPlainObject(platformRaw)) {
+                throw new NovelCliError(`Invalid ${file}: 'platform_multipliers.${platformId}' must be an object.`, 2);
+            }
+            const weightsRaw = platformRaw;
+            const parsedWeights = {};
+            for (const [dim, value] of Object.entries(weightsRaw)) {
+                if (!allowedDims.has(dim)) {
+                    throw new NovelCliError(`Invalid ${file}: unknown dimension '${dim}' in platform_multipliers.${platformId} (allowed: ${dimensions.join(", ")}).`, 2);
+                }
+                parsedWeights[dim] = requireFiniteNonNegativeNumber(value, file, `platform_multipliers.${platformId}.${dim}`);
+            }
+            platform_multipliers[platformId] = parsedWeights;
+        }
+        out.platform_multipliers = platform_multipliers;
+    }
     if (typeof obj.description === "string" && obj.description.trim().length > 0)
         out.description = obj.description.trim();
     if (typeof obj.last_updated === "string" && obj.last_updated.trim().length > 0)
@@ -188,6 +219,7 @@ export function computeEffectiveScoringWeights(args) {
     const dims = args.hookPolicy?.required ? configDims : configDims.filter((d) => d !== "hook_strength");
     const overridesRaw = args.scoring.weight_overrides ?? null;
     const overrides = overridesRaw ? { ...overridesRaw } : null;
+    const platformMultipliers = args.platformId !== undefined ? args.config.platform_multipliers?.[canonicalPlatformId(args.platformId)] ?? null : null;
     const allowedDims = new Set(configDims);
     const effectiveDims = new Set(dims);
     if (overrides) {
@@ -207,7 +239,9 @@ export function computeEffectiveScoringWeights(args) {
     }
     const rawWeights = {};
     for (const dim of dims) {
-        rawWeights[dim] = typeof overrides?.[dim] === "number" ? overrides[dim] : profile.weights[dim];
+        const baseWeight = typeof overrides?.[dim] === "number" ? overrides[dim] : profile.weights[dim];
+        const multiplier = platformMultipliers?.[dim] ?? 1.0;
+        rawWeights[dim] = baseWeight * multiplier;
     }
     const normalization = normalizeWeights({
         dimensions: dims,
@@ -247,7 +281,8 @@ export async function attachScoringWeightsToEval(args) {
     const effective = computeEffectiveScoringWeights({
         config: args.genreWeightProfiles.config,
         scoring,
-        hookPolicy: args.platformProfile.hook_policy
+        hookPolicy: args.platformProfile.hook_policy,
+        platformId: args.platformProfile.platform
     });
     const raw = await readJsonFile(args.evalAbsPath);
     if (!isPlainObject(raw))

package/dist/steps.js

@@ -10,7 +10,7 @@ export const ORCHESTRATOR_STATES = [
 ];
 export const CHAPTER_STAGES = ["draft", "summarize", "refine", "judge", "title-fix", "hook-fix", "review", "commit"];
 export const VOLUME_PHASES = ["outline", "validate", "commit"];
-export const QUICKSTART_PHASES = ["world", "characters", "style", "trial", "results"];
+export const QUICKSTART_PHASES = ["world", "characters", "style", "f0", "trial", "results"];
 export const REVIEW_PHASES = ["collect", "audit", "report", "cleanup", "transition"];
 export function pad3(n) {
     return String(n).padStart(3, "0");