novel-writer-cli 0.3.0 → 0.5.0

package/dist/gate-decision.js

@@ -38,10 +38,10 @@ export function detectHighConfidenceViolation(evalRaw) {
     return { has_high_confidence_violation: hardChecks.length > 0, high_confidence_violations: hardChecks };
 }
 export function computeGateDecision(args) {
-    const maxRevisions = typeof args.max_revisions === "number" && Number.isInteger(args.max_revisions) && args.max_revisions >= 0 ? args.max_revisions : 2;
+    const maxRevisions = normalizeMaxRevisions(args.max_revisions);
     if (args.force_pass)
         return "force_passed";
-    if (args.has_high_confidence_violation) {
+    if (args.has_high_confidence_violation || args.has_golden_chapter_gate_failure) {
         return args.revision_count >= maxRevisions ? "pause_for_user" : "revise";
     }
     const score = args.overall_final;
@@ -57,3 +57,99 @@ export function computeGateDecision(args) {
         return "pause_for_user";
     return "pause_for_user_force_rewrite";
 }
+function normalizeMaxRevisions(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 2;
+}
+export function normalizeGateRevisionCount(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+export function normalizeGateMaxRevisions(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function isGoldenChapterGateFailureStatus(value) {
+    return value === "fail" || value === "failed" || value === "violation";
+}
+export function detectGoldenChapterGateFailure(evalRaw) {
+    if (!isPlainObject(evalRaw))
+        return { has_golden_chapter_gate_failure: false, failed_checks: [] };
+    const evalObj = evalRaw;
+    const raw = evalObj.golden_chapter_gates;
+    if (!isPlainObject(raw))
+        return { has_golden_chapter_gate_failure: false, failed_checks: [] };
+    const gates = raw;
+    if (gates.activated === false)
+        return { has_golden_chapter_gate_failure: false, failed_checks: [] };
+    const failedChecks = [];
+    const seenIds = new Set();
+    const checksRaw = gates.checks;
+    if (Array.isArray(checksRaw)) {
+        for (const item of checksRaw) {
+            if (!isPlainObject(item))
+                continue;
+            const check = item;
+            if (!isGoldenChapterGateFailureStatus(check.status))
+                continue;
+            const id = typeof check.id === "string" && check.id.trim().length > 0 ? check.id.trim() : null;
+            if (id) {
+                if (seenIds.has(id))
+                    continue;
+                seenIds.add(id);
+                failedChecks.push({ ...check, id });
+                continue;
+            }
+            failedChecks.push(check);
+        }
+    }
+    const failedGateIdsRaw = gates.failed_gate_ids;
+    if (Array.isArray(failedGateIdsRaw)) {
+        for (const item of failedGateIdsRaw) {
+            if (typeof item !== "string" || item.trim().length === 0)
+                continue;
+            const id = item.trim();
+            if (seenIds.has(id))
+                continue;
+            seenIds.add(id);
+            failedChecks.push({ id, status: "fail" });
+        }
+    }
+    const hasFailure = gates.passed === false || failedChecks.length > 0;
+    return { has_golden_chapter_gate_failure: hasFailure, failed_checks: failedChecks };
+}
+export function evaluateGateDecisionFromEval(args) {
+    if (!isPlainObject(args.evalRaw))
+        return { ok: false, reason: "eval_invalid" };
+    const evalObj = args.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 { ok: false, reason: "eval_missing_overall" };
+    }
+    const maxRevisions = normalizeGateMaxRevisions(args.max_revisions);
+    const violation = detectHighConfidenceViolation(evalObj);
+    const goldenGateFailure = detectGoldenChapterGateFailure(evalObj);
+    const decision = computeGateDecision({
+        overall_final: overall,
+        revision_count: args.revision_count,
+        has_high_confidence_violation: violation.has_high_confidence_violation,
+        has_golden_chapter_gate_failure: goldenGateFailure.has_golden_chapter_gate_failure,
+        ...(maxRevisions === null ? {} : { max_revisions: maxRevisions }),
+        ...(args.force_pass ? { force_pass: true } : {})
+    });
+    return {
+        ok: true,
+        gate: {
+            overall_final: overall,
+            decision,
+            revision_count: args.revision_count,
+            max_revisions: maxRevisions,
+            has_high_confidence_violation: violation.has_high_confidence_violation,
+            high_confidence_violations: violation.high_confidence_violations,
+            has_golden_chapter_gate_failure: goldenGateFailure.has_golden_chapter_gate_failure,
+            golden_chapter_gate_failures: goldenGateFailure.failed_checks,
+            recommendation: typeof evalObj.recommendation === "string" ? evalObj.recommendation : null
+        }
+    };
+}

package/dist/golden-chapter-gates.js

@@ -0,0 +1,143 @@
+import { join } from "node:path";
+import { NovelCliError } from "./errors.js";
+import { pathExists, readJsonFile } from "./fs-utils.js";
+import { CANONICAL_PLATFORM_IDS, canonicalPlatformId } from "./platform-profile.js";
+import { isPlainObject } from "./type-guards.js";
+const VALID_THRESHOLD_OPERATORS = ["<", "<=", ">", ">=", "==", "!="];
+function requireString(value, file, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new NovelCliError(`Invalid ${file}: '${field}' must be a non-empty string.`, 2);
+    }
+    return value.trim();
+}
+function requireOptionalStringArray(value, file, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string" && item.trim().length > 0)) {
+        throw new NovelCliError(`Invalid ${file}: '${field}' must be a string array.`, 2);
+    }
+    return value.map((item) => item.trim());
+}
+function parseRule(raw, file, field) {
+    if (!isPlainObject(raw))
+        throw new NovelCliError(`Invalid ${file}: '${field}' must be an object.`, 2);
+    const obj = raw;
+    const out = {
+        id: requireString(obj.id, file, `${field}.id`),
+        requirement: requireString(obj.requirement, file, `${field}.requirement`)
+    };
+    if (obj.evaluation_hint !== undefined) {
+        out.evaluation_hint = requireString(obj.evaluation_hint, file, `${field}.evaluation_hint`);
+    }
+    if (obj.threshold !== undefined) {
+        if (!isPlainObject(obj.threshold))
+            throw new NovelCliError(`Invalid ${file}: '${field}.threshold' must be an object.`, 2);
+        const threshold = obj.threshold;
+        const value = threshold.value;
+        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+            throw new NovelCliError(`Invalid ${file}: '${field}.threshold.value' must be string|number|boolean.`, 2);
+        }
+        const operator = requireString(threshold.operator, file, `${field}.threshold.operator`);
+        if (!VALID_THRESHOLD_OPERATORS.includes(operator)) {
+            throw new NovelCliError(`Invalid ${file}: '${field}.threshold.operator' must be one of: ${VALID_THRESHOLD_OPERATORS.join(", ")}.`, 2);
+        }
+        out.threshold = {
+            metric: requireString(threshold.metric, file, `${field}.threshold.metric`),
+            operator,
+            value
+        };
+    }
+    const allowed_values = requireOptionalStringArray(obj.allowed_values, file, `${field}.allowed_values`);
+    if (allowed_values)
+        out.allowed_values = allowed_values;
+    return out;
+}
+function parseChapterConfig(raw, file, field) {
+    if (!isPlainObject(raw))
+        throw new NovelCliError(`Invalid ${file}: '${field}' must be an object.`, 2);
+    const obj = raw;
+    const gatesRaw = obj.gates;
+    if (!Array.isArray(gatesRaw) || gatesRaw.length === 0) {
+        throw new NovelCliError(`Invalid ${file}: '${field}.gates' must be a non-empty array.`, 2);
+    }
+    const gates = gatesRaw.map((item, index) => parseRule(item, file, `${field}.gates[${index}]`));
+    const notes = requireOptionalStringArray(obj.notes, file, `${field}.notes`);
+    return notes ? { gates, notes } : { gates };
+}
+export function parseGoldenChapterGates(raw, file) {
+    if (!isPlainObject(raw))
+        throw new NovelCliError(`Invalid ${file}: expected a JSON object.`, 2);
+    const obj = raw;
+    if (obj.schema_version !== 1)
+        throw new NovelCliError(`Invalid ${file}: 'schema_version' must be 1.`, 2);
+    if (!isPlainObject(obj.platforms))
+        throw new NovelCliError(`Invalid ${file}: 'platforms' must be an object.`, 2);
+    const platformsRaw = obj.platforms;
+    const platforms = {};
+    for (const platformId of CANONICAL_PLATFORM_IDS) {
+        const platformRaw = platformsRaw[platformId];
+        if (!isPlainObject(platformRaw)) {
+            throw new NovelCliError(`Invalid ${file}: missing 'platforms.${platformId}' object.`, 2);
+        }
+        const platformObj = platformRaw;
+        if (!isPlainObject(platformObj.chapters)) {
+            throw new NovelCliError(`Invalid ${file}: 'platforms.${platformId}.chapters' must be an object.`, 2);
+        }
+        const chaptersRaw = platformObj.chapters;
+        const chapters = {};
+        for (const chapter of ["1", "2", "3"]) {
+            chapters[chapter] = parseChapterConfig(chaptersRaw[chapter], file, `platforms.${platformId}.chapters.${chapter}`);
+        }
+        platforms[platformId] = { chapters };
+    }
+    if (!Array.isArray(obj.invalid_combinations)) {
+        throw new NovelCliError(`Invalid ${file}: 'invalid_combinations' must be an array.`, 2);
+    }
+    const invalid_combinations = obj.invalid_combinations.map((item, index) => {
+        if (!isPlainObject(item)) {
+            throw new NovelCliError(`Invalid ${file}: 'invalid_combinations[${index}]' must be an object.`, 2);
+        }
+        const entry = item;
+        const platform = requireString(entry.platform, file, `invalid_combinations[${index}].platform`);
+        if (!CANONICAL_PLATFORM_IDS.includes(platform)) {
+            throw new NovelCliError(`Invalid ${file}: 'invalid_combinations[${index}].platform' must be one of ${CANONICAL_PLATFORM_IDS.join(", ")}.`, 2);
+        }
+        return {
+            genre: requireString(entry.genre, file, `invalid_combinations[${index}].genre`),
+            platform: platform,
+            warning: requireString(entry.warning, file, `invalid_combinations[${index}].warning`)
+        };
+    });
+    const out = { schema_version: 1, invalid_combinations, platforms };
+    if (typeof obj.description === "string" && obj.description.trim().length > 0)
+        out.description = obj.description.trim();
+    return out;
+}
+export async function loadGoldenChapterGates(rootDir) {
+    const relPath = "golden-chapter-gates.json";
+    const absPath = join(rootDir, relPath);
+    if (!(await pathExists(absPath)))
+        return null;
+    const raw = await readJsonFile(absPath);
+    return { relPath, config: parseGoldenChapterGates(raw, relPath) };
+}
+export function selectGoldenChapterGatesForPlatform(args) {
+    if (!Number.isInteger(args.chapter) || args.chapter < 1 || args.chapter > 3)
+        return null;
+    const platform = canonicalPlatformId(args.platformId);
+    const platformConfig = args.config.platforms[platform];
+    if (!platformConfig)
+        return null;
+    const current_chapter = platformConfig.chapters[String(args.chapter)];
+    if (!current_chapter)
+        return null;
+    return {
+        platform,
+        chapter: args.chapter,
+        current_chapter,
+        chapters: platformConfig.chapters,
+        invalid_combination_warnings: args.config.invalid_combinations
+            .filter((item) => item.platform === platform)
+            .map((item) => ({ genre: item.genre, warning: item.warning }))
+    };
+}

package/dist/init.js

@@ -1,6 +1,7 @@
 import { stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { canonicalPlatformId } from "./platform-profile.js";
 import { createDefaultCheckpoint } from "./checkpoint.js";
 import { NovelCliError } from "./errors.js";
 import { ensureDir, pathExists, readJsonFile, readTextFile, writeJsonFile, writeTextFile } from "./fs-utils.js";
@@ -14,9 +15,9 @@ export function resolveInitRootDir(args) {
     return resolve(cwdAbs, args.projectOverride);
 }
 export function normalizePlatformId(value) {
-    if (value === "qidian" || value === "tomato")
+    if (value === "qidian" || value === "tomato" || value === "fanqie" || value === "jinjiang")
         return value;
-    throw new NovelCliError(`Invalid --platform: ${String(value)} (expected qidian|tomato).`, 2);
+    throw new NovelCliError(`Invalid --platform: ${String(value)} (expected qidian|tomato|fanqie|jinjiang).`, 2);
 }
 function moduleRootDir() {
     // src/init.ts → <repo_root>; dist/init.js → <package_root>
@@ -40,7 +41,21 @@ async function ensureRootIsDirectory(absPath) {
 }
 async function writeIfMissingOrForce(args) {
     const abs = join(args.rootDir, args.relPath);
-    const exists = await pathExists(abs);
+    let exists = false;
+    try {
+        const current = await stat(abs);
+        if (!current.isFile()) {
+            throw new NovelCliError(`Cannot initialize ${args.relPath}: existing path is not a file. Remove it or choose a different project root.`, 2);
+        }
+        exists = true;
+    }
+    catch (err) {
+        if (err instanceof NovelCliError)
+            throw err;
+        const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : null;
+        if (code !== "ENOENT")
+            throw err;
+    }
     if (exists && !args.force) {
         args.result.skipped.push(args.relPath);
         return;
@@ -93,9 +108,32 @@ async function loadPlatformProfileTemplate(platform) {
     }
     return selected;
 }
+async function tryLoadPlatformWritingGuide(platform) {
+    const canonicalPlatform = canonicalPlatformId(platform);
+    const relPath = `platforms/${canonicalPlatform}.md`;
+    const absPath = join(TEMPLATE_DIR, relPath);
+    if (!(await pathExists(absPath))) {
+        return {
+            text: null,
+            warning: `Missing optional platform writing guide template: templates/${relPath}. Init continued without platform-writing-guide.md.`
+        };
+    }
+    try {
+        return { text: await readTextFile(absPath), warning: null };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            text: null,
+            warning: `Failed to read optional platform writing guide template: templates/${relPath}. ${message}`
+        };
+    }
+}
 const DEFAULT_TEMPLATES = [
     { relPath: "brief.md", templateName: "brief-template.md", kind: "text" },
     { relPath: "style-profile.json", templateName: "style-profile-template.json", kind: "json" },
+    { relPath: "genre-excitement-map.json", templateName: "genre-excitement-map.json", kind: "json" },
+    { relPath: "genre-golden-standards.json", templateName: "genre-golden-standards.json", kind: "json" },
     { relPath: "ai-blacklist.json", templateName: "ai-blacklist.json", kind: "json" },
     { relPath: "web-novel-cliche-lint.json", templateName: "web-novel-cliche-lint.json", kind: "json" }
 ];
@@ -120,7 +158,8 @@ export async function initProject(args) {
         ensuredDirs: [],
         created: [],
         overwritten: [],
-        skipped: []
+        skipped: [],
+        warnings: []
     };
     await ensureRootIsDirectory(args.rootDir);
     for (const relDir of STAGING_SUBDIRS) {
@@ -138,9 +177,19 @@ export async function initProject(args) {
     });
     if (!minimal) {
         for (const tmpl of DEFAULT_TEMPLATES) {
-            const contents = tmpl.kind === "text"
-                ? { kind: "text", text: await loadTemplateText(tmpl.templateName) }
-                : { kind: "json", json: await loadTemplateJson(tmpl.templateName) };
+            let contents;
+            if (tmpl.kind === "text") {
+                contents = { kind: "text", text: await loadTemplateText(tmpl.templateName) };
+            }
+            else {
+                const json = await loadTemplateJson(tmpl.templateName);
+                if (tmpl.relPath === "style-profile.json" && platform) {
+                    contents = { kind: "json", json: { ...json, platform } };
+                }
+                else {
+                    contents = { kind: "json", json };
+                }
+            }
             await writeIfMissingOrForce({ rootDir: args.rootDir, relPath: tmpl.relPath, contents, force, result });
         }
     }
@@ -161,6 +210,26 @@ export async function initProject(args) {
             force,
             result
         });
+        await writeIfMissingOrForce({
+            rootDir: args.rootDir,
+            relPath: "golden-chapter-gates.json",
+            contents: { kind: "json", json: await loadTemplateJson("golden-chapter-gates.json") },
+            force,
+            result
+        });
+        const guide = await tryLoadPlatformWritingGuide(platform);
+        if (guide.text !== null) {
+            await writeIfMissingOrForce({
+                rootDir: args.rootDir,
+                relPath: "platform-writing-guide.md",
+                contents: { kind: "text", text: guide.text },
+                force,
+                result
+            });
+        }
+        else if (guide.warning) {
+            result.warnings.push(guide.warning);
+        }
     }
     return result;
 }