novel-writer-cli 0.0.1

package/dist/fingerprint.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+export function hashText(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+export async function fingerprintTextFile(absPath) {
+    const [s, text] = await Promise.all([stat(absPath), readFile(absPath, "utf8")]);
+    return { fingerprint: { size: s.size, mtime_ms: s.mtimeMs, content_hash: hashText(text) }, text };
+}
+export async function fingerprintFile(absPath) {
+    const { fingerprint } = await fingerprintTextFile(absPath);
+    return fingerprint;
+}
+export function fingerprintsMatch(a, b) {
+    return a.size === b.size && a.mtime_ms === b.mtime_ms && a.content_hash === b.content_hash;
+}

package/dist/foreshadow-visibility.js

@@ -0,0 +1,214 @@
+import { rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureDir, pathExists, readJsonFile, writeJsonFile } from "./fs-utils.js";
+import { pad2, pad3 } from "./steps.js";
+import { isPlainObject } from "./type-guards.js";
+function safeInt(v) {
+    return typeof v === "number" && Number.isInteger(v) && v >= 0 ? v : null;
+}
+function safeString(v) {
+    return typeof v === "string" && v.trim().length > 0 ? v.trim() : null;
+}
+function normalizeScope(raw) {
+    if (raw === "short" || raw === "medium" || raw === "long")
+        return raw;
+    return "medium";
+}
+function normalizeStatus(raw) {
+    if (raw === "planted" || raw === "advanced" || raw === "resolved")
+        return raw;
+    return "planted";
+}
+export function deriveForeshadowDormancyThresholds(genreDriveType) {
+    // Base thresholds in chapters; adjusted by genre_drive_type.
+    // Intent: keep long-scope items from going silent too long, without forcing spoilers.
+    const base = { short: 6, medium: 12, long: 24 };
+    const dt = genreDriveType ?? "";
+    const adjust = dt === "suspense" ? -3 : dt === "plot" ? -2 : dt === "character" ? -1 : dt === "slice_of_life" ? 2 : 0;
+    const clamp = (n) => Math.max(1, n);
+    return {
+        short: clamp(base.short + adjust),
+        medium: clamp(base.medium + adjust),
+        long: clamp(base.long + adjust)
+    };
+}
+function normalizeForeshadowList(raw) {
+    let list = [];
+    if (Array.isArray(raw)) {
+        list = raw;
+    }
+    else if (isPlainObject(raw)) {
+        const obj = raw;
+        if (Array.isArray(obj.foreshadowing))
+            list = obj.foreshadowing;
+    }
+    const out = [];
+    for (const it of list) {
+        if (!isPlainObject(it))
+            continue;
+        const id = safeString(it.id);
+        if (!id)
+            continue;
+        out.push({ ...it, id });
+    }
+    return out;
+}
+function compareStrings(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function makeLightTouchTasks(args) {
+    const scopeHint = args.scope === "short" ? "短期" : args.scope === "medium" ? "中期" : "长期";
+    const statusHint = args.status === "resolved" ? "已回收" : args.status === "advanced" ? "已推进" : "已埋设";
+    const common = `伏笔「${args.label}」已沉默 ${args.chaptersSince} 章（${scopeHint}/${statusHint}）`;
+    return {
+        planning_task: `${common}。建议在接下来几章安排一次“轻触”回响（象征/道具/一句话提及），保持读者记忆，不要提前兑现。`,
+        writing_task: `${common}。本章请用 1 句/1 个意象/1 个小动作做“轻触”回响（不解释、不揭底、不兑现）。`
+    };
+}
+export function computeForeshadowVisibilityReport(args) {
+    if (!Number.isInteger(args.asOfChapter) || args.asOfChapter < 0)
+        throw new Error(`Invalid asOfChapter: ${String(args.asOfChapter)}`);
+    if (!Number.isInteger(args.volume) || args.volume < 0)
+        throw new Error(`Invalid volume: ${String(args.volume)}`);
+    const thresholds = deriveForeshadowDormancyThresholds(args.genreDriveType);
+    const dormant = [];
+    for (const it of args.items) {
+        const status = normalizeStatus(it.status);
+        if (status === "resolved")
+            continue;
+        const scope = normalizeScope(it.scope);
+        const lastUpdated = safeInt(it.last_updated_chapter) ?? safeInt(it.planted_chapter) ?? 0;
+        const chaptersSince = Math.max(0, args.asOfChapter - lastUpdated);
+        const threshold = thresholds[scope];
+        if (chaptersSince < threshold)
+            continue;
+        const description = safeString(it.description);
+        const label = description ?? it.id;
+        const tasks = makeLightTouchTasks({ id: it.id, label, scope, status, chaptersSince });
+        dormant.push({
+            id: it.id,
+            description,
+            scope,
+            status,
+            last_updated_chapter: lastUpdated,
+            chapters_since_last_update: chaptersSince,
+            dormancy_threshold: threshold,
+            ...tasks
+        });
+    }
+    dormant.sort((a, b) => b.chapters_since_last_update - a.chapters_since_last_update || compareStrings(a.scope, b.scope) || compareStrings(a.id, b.id));
+    const dormantByScope = { short: 0, medium: 0, long: 0 };
+    for (const it of dormant)
+        dormantByScope[it.scope] += 1;
+    return {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        as_of: { chapter: args.asOfChapter, volume: args.volume },
+        platform: args.platform,
+        genre_drive_type: args.genreDriveType,
+        thresholds,
+        dormant_items: dormant,
+        counts: { dormant_total: dormant.length, dormant_by_scope: dormantByScope }
+    };
+}
+export async function writeForeshadowVisibilityLogs(args) {
+    const dirRel = "logs/foreshadowing";
+    const dirAbs = join(args.rootDir, dirRel);
+    await ensureDir(dirAbs);
+    const latestRel = `${dirRel}/latest.json`;
+    const latestAbs = join(args.rootDir, latestRel);
+    const result = { latestRel };
+    if (args.historyRange) {
+        const start = args.historyRange.start;
+        const end = args.historyRange.end;
+        const historyRel = `${dirRel}/foreshadow-visibility-vol-${pad2(args.report.as_of.volume)}-ch${pad3(start)}-ch${pad3(end)}.json`;
+        await writeJsonFile(join(args.rootDir, historyRel), args.report);
+        result.historyRel = historyRel;
+    }
+    const parseLatest = (raw) => {
+        if (!isPlainObject(raw))
+            return null;
+        const obj = raw;
+        if (obj.schema_version !== 1)
+            return null;
+        const asOf = obj.as_of;
+        if (!isPlainObject(asOf))
+            return null;
+        const chapter = asOf.chapter;
+        if (typeof chapter !== "number" || !Number.isInteger(chapter) || chapter < 0)
+            return null;
+        const rawTs = typeof obj.generated_at === "string" ? obj.generated_at : null;
+        const generated_at = rawTs && Number.isFinite(Date.parse(rawTs)) ? rawTs : null;
+        return { chapter, generated_at };
+    };
+    const next = { chapter: args.report.as_of.chapter, generated_at: args.report.generated_at };
+    let shouldWriteLatest = true;
+    if (await pathExists(latestAbs)) {
+        try {
+            const existing = parseLatest(await readJsonFile(latestAbs));
+            if (existing) {
+                if (existing.chapter > next.chapter) {
+                    shouldWriteLatest = false;
+                }
+                else if (existing.chapter === next.chapter) {
+                    // If timestamps are comparable, keep the newer one; otherwise, overwrite.
+                    if (existing.generated_at) {
+                        const a = Date.parse(existing.generated_at);
+                        const b = Date.parse(next.generated_at);
+                        if (Number.isFinite(a) && Number.isFinite(b) && a >= b)
+                            shouldWriteLatest = false;
+                    }
+                }
+            }
+        }
+        catch {
+            shouldWriteLatest = true;
+        }
+    }
+    if (shouldWriteLatest) {
+        // Atomic replace to avoid partial/corrupted JSON on interruption.
+        const tmpAbs = join(dirAbs, `.tmp-foreshadowing-latest-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
+        await writeJsonFile(tmpAbs, args.report);
+        try {
+            // Re-check right before publish to reduce (not eliminate) races without introducing a lock.
+            let stillWrite = true;
+            if (await pathExists(latestAbs)) {
+                try {
+                    const existing2 = parseLatest(await readJsonFile(latestAbs));
+                    if (existing2) {
+                        if (existing2.chapter > next.chapter) {
+                            stillWrite = false;
+                        }
+                        else if (existing2.chapter === next.chapter && existing2.generated_at) {
+                            const a = Date.parse(existing2.generated_at);
+                            const b = Date.parse(next.generated_at);
+                            if (Number.isFinite(a) && Number.isFinite(b) && a >= b)
+                                stillWrite = false;
+                        }
+                    }
+                }
+                catch {
+                    stillWrite = true;
+                }
+            }
+            if (stillWrite)
+                await rename(tmpAbs, latestAbs);
+        }
+        finally {
+            await rm(tmpAbs, { force: true }).catch(() => { });
+        }
+    }
+    return result;
+}
+export async function loadForeshadowGlobalItems(rootDir) {
+    const rel = "foreshadowing/global.json";
+    const abs = join(rootDir, rel);
+    if (!(await pathExists(abs)))
+        return [];
+    const raw = await readJsonFile(abs);
+    return normalizeForeshadowList(raw);
+}

package/dist/fs-utils.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { NovelCliError } from "./errors.js";
+export async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(path) {
+    await mkdir(path, { recursive: true });
+}
+export async function readTextFile(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Failed to read file: ${path}. ${message}`);
+    }
+}
+export async function readJsonFile(path) {
+    const raw = await readTextFile(path);
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Invalid JSON: ${path}. ${message}`);
+    }
+}
+export async function writeTextFile(path, contents) {
+    try {
+        await ensureDir(dirname(path));
+        await writeFile(path, contents, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Failed to write file: ${path}. ${message}`);
+    }
+}
+export async function writeTextFileIfMissing(path, contents) {
+    try {
+        await ensureDir(dirname(path));
+        await writeFile(path, contents, { encoding: "utf8", flag: "wx" });
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "EEXIST")
+            return;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Failed to write file: ${path}. ${message}`);
+    }
+}
+export async function writeJsonFile(path, payload) {
+    await writeTextFile(path, `${JSON.stringify(payload, null, 2)}\n`);
+}
+export async function removePath(path) {
+    try {
+        await rm(path, { recursive: true, force: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new NovelCliError(`Failed to remove path: ${path}. ${message}`);
+    }
+}