novelforge-agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linkzhao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,240 @@
+# NovelForge Agent
+
+A local-first long-form novel workflow engine for any MCP host (Claude Code, Codex CLI, …) or any CLI shell.
+
+**The host's LLM writes the prose. This package does everything else** — it manages a 9-step state machine, returns the exact instruction and packed context the host should follow next, validates returned content against zod schemas, persists Markdown + JSON to a project directory, archives chapter versions on revision, and provides BM25 lexical retrieval over every word the project has ever produced.
+
+No external API. No LLM dependency. No vendor lock-in.
+
+## What it gives the host
+
+| Phase | Step | What the host does | What the agent saves |
+|-------|------|---------------------|----------------------|
+| Setup | `novel_metadata` | Output JSON: title, genre, premise, cast | `novel.json` |
+|  | `story_bible` | Output Markdown: characters, world rules, plot threads | `story-bible.md` |
+|  | `architecture` | Output JSON: full / volume / chapter outlines | `architecture/{full.md, volumes.json, chapters.json}` |
+| Loop  | `chapter` | Write chapter N Markdown | `chapters/NNN.md` |
+|  | `memory_card` | Extract chapter N memory JSON | `memory/chapter-NNN.json` |
+| Wrap  | `continuity_review` | Audit chapters 1..N for conflicts | `reviews/continuity-S-E.json` |
+| Side-track | `chapter_review` | Single-chapter editorial review | `reviews/chapter/chapter-NNN.json` |
+|  | `chapter_revision` | Rewrite a chapter; previous version auto-archived | `chapters/.versions/NNN.<ts>.md` |
+|  | `cross_chapter_review` | Cross-chapter continuity audit | `reviews/cross/cross-S-E.json` |
+
+Each chapter / bible / memory write also feeds a per-project BM25 index (`.index/`) so the agent can hand the host semantically relevant snippets when later chapters are generated, or answer ad-hoc `retrieve` queries from the host.
+
+## Install
+
+Requires Node 20+.
+
+```bash
+git clone <this repo>
+cd novelforge-agent
+npm install
+npm run build
+```
+
+Run the test suite to confirm:
+
+```bash
+npm test
+```
+
+## Use it from a CLI shell
+
+```bash
+# 1. Start a new project
+node dist/src/cli/index.js start --prompt "写一本赛博修仙小说" --chapters 5
+# → prints { state, next } — next.instruction is the prompt for step 1
+
+# 2. List existing projects
+node dist/src/cli/index.js list
+# → newest first, with current step and chapter count
+
+# 3. Show one project's status
+node dist/src/cli/index.js status novels/<slug>
+
+# 4. Get the next step's instruction + context
+node dist/src/cli/index.js next novels/<slug>
+
+# 5. Submit your generated content (file containing JSON or Markdown)
+node dist/src/cli/index.js submit novels/<slug> --step chapter --file ch1.md
+
+# 6. Trigger a single-chapter review
+node dist/src/cli/index.js review novels/<slug> --chapter 3
+
+# 7. Trigger a revision (feedback can be a literal string or --feedback-file)
+node dist/src/cli/index.js revise novels/<slug> --chapter 3 --feedback "让节奏更紧"
+
+# 8. Cross-chapter audit (defaults to all generated chapters)
+node dist/src/cli/index.js cross-review novels/<slug> --start 1 --end 5
+
+# 9. Lexical retrieval over chapters + bible + memory cards
+node dist/src/cli/index.js retrieve novels/<slug> \
+  --query "昆吾剑" --top-k 8 --types chapter,memory --start 1 --end 5
+
+# 10. Build purpose-specific context (useful for debugging prompts)
+node dist/src/cli/index.js context novels/<slug> \
+  --purpose chapter_generation --chapter 4
+```
+
+English projects: pass `--language en-US` to `start`. Every prompt has a parallel English form in [src/core/prompts/en-US.ts](src/core/prompts/en-US.ts).
+
+## Use it as an MCP server
+
+### Claude Code
+
+```jsonc
+// ~/.claude.json  (or your project's .mcp.json)
+{
+  "mcpServers": {
+    "novelforge": {
+      "command": "node",
+      "args": ["/absolute/path/to/novelforge-agent/dist/src/mcp/server.js"],
+      "env": {
+        "NOVELFORGE_WORKSPACE": "/absolute/path/where/projects/should/live"
+      }
+    }
+  }
+}
+```
+
+Reload Claude Code and type:
+
+> 我想写一本赛博修仙小说
+
+Claude will discover the `start_novel_project` tool, call it, get back the first prompt for `novel_metadata`, generate the JSON, call `submit_step_result`, get back the next prompt, and continue autonomously until `complete`.
+
+### Codex CLI
+
+```toml
+# ~/.codex/config.toml
+[mcp_servers.novelforge]
+command = "node"
+args = ["/absolute/path/to/novelforge-agent/dist/src/mcp/server.js"]
+
+[mcp_servers.novelforge.env]
+NOVELFORGE_WORKSPACE = "/absolute/path/where/projects/should/live"
+```
+
+### Resuming work in a later session
+
+`list_projects` finds every project under `NOVELFORGE_WORKSPACE/novels/`, sorted newest first. The host should call it before anything else when a session opens; pick the desired `projectPath` from the result, then `get_project_status` for a one-screen briefing, then `get_next_step` to resume.
+
+## Tool reference (13 MCP tools)
+
+### Project lifecycle
+- **`start_novel_project`** `(prompt, language?, outputDir?, targetChapters?)` — create a new project under `<workspaceRoot>/<outputDir>/<slug>-<rand6>/` and return the first step's instruction.
+- **`list_projects`** `(outputDir?)` — list all projects in the workspace, newest first.
+- **`get_project_status`** `(projectPath)` — compact summary: current step, chapters written, open threads, latest review verdict.
+- **`get_next_step`** `(projectPath)` — return the prompt + packed context for whatever the workflow expects next.
+
+### Workflow advancement
+- **`submit_step_result`** `(projectPath, step, content)` — validate `content` against the step's zod schema, persist it, advance the state machine. On failure the bad submission is written to `.agent-recovery/failed-*.txt` and the state does not advance.
+- **`get_context`** `(projectPath, purpose, chapterNumber?, start?, end?)` — build purpose-specific context without changing state. Useful when the host wants to read what the agent *would* have packed.
+
+### Semantic actions (verb-style; safe to call any time)
+- **`generate_chapter`** `(projectPath, chapterNumber)` — return generation context for a specific chapter.
+- **`extract_memory_card`** `(projectPath, chapterNumber)` — return memory-extraction context for a specific chapter.
+- **`review_chapter`** `(projectPath, chapterNumber)` — switch into a single-chapter editorial review side-track and return its prompt. After `submit_step_result(step="chapter_review")`, the workflow resumes its prior step automatically.
+- **`revise_chapter`** `(projectPath, chapterNumber, feedback?)` — switch into a chapter-revision side-track. Submitting `chapter_revision` content auto-archives the previous version under `chapters/.versions/`.
+- **`cross_chapter_review`** `(projectPath, start?, end?)` — switch into a cross-chapter audit side-track over the given range (defaults to all generated chapters).
+- **`save_chapter`** `(projectPath, chapterNumber, title, content)` — write a chapter Markdown file directly, without going through the state machine.
+
+### Retrieval
+- **`retrieve`** `(projectPath, query, topK?, types?, chapterStart?, chapterEnd?)` — BM25-style lexical retrieval over indexed paragraphs (chapters), bible H2 sections, and memory cards. Supports CJK + Latin queries via a built-in CJK bigram tokenizer; no external embedding model.
+
+## Project layout
+
+A project on disk:
+
+```
+novels/<slug>-<rand6>/
+├── agent-state.json              # workflow state (currentStep, currentChapter, files map, …)
+├── novel.json                    # metadata (NovelMetadataSchema)
+├── story-bible.md
+├── architecture/
+│   ├── full.md
+│   ├── volumes.json
+│   └── chapters.json
+├── chapters/
+│   ├── 001.md
+│   ├── 002.md
+│   └── .versions/                # archived pre-revision chapter snapshots
+├── memory/
+│   └── chapter-001.json
+├── reviews/
+│   ├── continuity-1-N.json
+│   ├── chapter/chapter-NNN.json
+│   └── cross/cross-S-E.json
+├── .index/
+│   ├── lexical.json              # MiniSearch serialization
+│   └── manifest.json             # external doc id list
+└── .agent-recovery/
+    ├── failed-*.txt              # rejected submissions kept for inspection
+    └── side-track.json           # resume hint when in a review/revision side-track
+```
+
+The whole directory is self-contained — copy it, share it, delete it.
+
+## How the workflow advances
+
+```
+novel_metadata → story_bible → architecture → chapter
+                                              ↓
+                                          memory_card
+                                              ↓
+                              ┌───────────────┴───────────────┐
+                  (more chapters)                       (all done)
+                              ↓                               ↓
+                          chapter                    continuity_review
+                                                              ↓
+                                                          complete
+```
+
+Side-track steps (`chapter_review`, `chapter_revision`, `cross_chapter_review`) can be triggered at any moment via the semantic-action tools. When the side-track completes via `submit_step_result`, the workflow returns to whatever `currentStep` it was on before the side-track started.
+
+The full transition map lives in the `next:` declaration of each handler under [src/core/steps/](src/core/steps/). To change the workflow, edit those files — that is the entire state machine, there is no graph engine.
+
+## Architecture
+
+```
+src/
+├── core/                         # pure domain logic, no transport
+│   ├── types.ts                  # AgentState, WorkflowStep, MemoryCard, …
+│   ├── schemas.ts                # zod schemas (the only validator)
+│   ├── projectStore.ts           # filesystem persistence
+│   ├── projectDiscovery.ts       # list / status
+│   ├── prompts/                  # per-language prompt packs (zh-CN, en-US)
+│   ├── steps/                    # one file per WorkflowStep handler
+│   ├── retrieval/                # BM25 index + CJK tokenizer + chunker
+│   ├── contextBuilder.ts         # purpose-specific context packing
+│   └── workflow.ts               # dispatcher: contextForStep + side-track + submit
+├── mcp/
+│   ├── server.ts                 # stdio entrypoint
+│   └── tools.ts                  # 13 MCP tool registrations
+└── cli/
+    └── index.ts                  # equivalent CLI subcommands
+```
+
+The agent has no LLM dependency:
+
+```bash
+$ grep -RIl "anthropic\|openai\|@google" src package.json
+# (no results)
+```
+
+Only `@modelcontextprotocol/sdk`, `zod`, `minisearch`.
+
+## Adding a new workflow step
+
+1. Add the step name to `WorkflowStep` in [src/core/types.ts](src/core/types.ts).
+2. Add a zod schema in [src/core/schemas.ts](src/core/schemas.ts) (if the step accepts structured content).
+3. Add a prompt builder in [src/core/prompts/zh-CN.ts](src/core/prompts/zh-CN.ts) and [src/core/prompts/en-US.ts](src/core/prompts/en-US.ts).
+4. Create a handler under `src/core/steps/<name>.ts` returning a `StepApplyResult`.
+5. Register it in [src/core/steps/index.ts](src/core/steps/index.ts).
+6. (If the step needs packed context) add an entry to `CONTEXT_RECIPES` in [src/core/workflow.ts](src/core/workflow.ts).
+7. Add the step name to the `step` enum in [src/mcp/tools.ts](src/mcp/tools.ts) `submit_step_result`.
+
+## Design principle
+
+The host's LLM is the only thing in this system that thinks. The agent is a pure I/O machine that knows the *order* of work, the *shape* of every artifact, and the *vocabulary* of the domain — and refuses to let the host save anything that violates those rules. Long-form fiction needs that discipline more than it needs another LLM wrapper.

package/dist/src/cli/index.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { buildContext, createProject, getNextStep, getProjectStatus, listProjects, requestSideTrack, retrieve, submitStepResult, } from '../core/index.js';
+function valueAfter(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function parseLanguage(value) {
+    if (value === 'zh-CN' || value === 'en-US')
+        return value;
+    throw new Error('Invalid --language. Use zh-CN or en-US');
+}
+export async function runCli(argv = process.argv.slice(2), cwd = process.cwd()) {
+    const [command, projectPath] = argv;
+    if (command === 'start') {
+        const prompt = valueAfter(argv, '--prompt') || '';
+        if (!prompt.trim())
+            throw new Error('Missing --prompt');
+        const language = parseLanguage(valueAfter(argv, '--language') || 'zh-CN');
+        const chapters = Number(valueAfter(argv, '--chapters') || 3);
+        const outputDir = valueAfter(argv, '--output') || 'novels';
+        const result = await createProject({ workspaceRoot: cwd, prompt, language, outputDir, targetChapters: chapters });
+        const next = await getNextStep(result.state.projectPath);
+        console.log(JSON.stringify({ state: result.state, next }, null, 2));
+        return;
+    }
+    if (command === 'next') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        console.log(JSON.stringify(await getNextStep(projectPath), null, 2));
+        return;
+    }
+    if (command === 'submit') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const step = valueAfter(argv, '--step');
+        const file = valueAfter(argv, '--file');
+        if (!step || !file)
+            throw new Error('Missing --step or --file');
+        const content = await readFile(file, 'utf8');
+        console.log(JSON.stringify(await submitStepResult({ projectPath, step: step, content }), null, 2));
+        return;
+    }
+    if (command === 'context') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const purpose = valueAfter(argv, '--purpose') || 'chapter_generation';
+        const chapter = valueAfter(argv, '--chapter');
+        const start = valueAfter(argv, '--start');
+        const end = valueAfter(argv, '--end');
+        console.log(await buildContext({
+            projectPath,
+            purpose: purpose,
+            chapterNumber: chapter ? Number(chapter) : undefined,
+            range: start && end ? { start: Number(start), end: Number(end) } : undefined,
+        }));
+        return;
+    }
+    if (command === 'review') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const chapter = valueAfter(argv, '--chapter');
+        if (!chapter)
+            throw new Error('Missing --chapter');
+        console.log(JSON.stringify(await requestSideTrack({ projectPath, step: 'chapter_review', chapterNumber: Number(chapter) }), null, 2));
+        return;
+    }
+    if (command === 'revise') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const chapter = valueAfter(argv, '--chapter');
+        if (!chapter)
+            throw new Error('Missing --chapter');
+        const feedbackFile = valueAfter(argv, '--feedback-file');
+        const feedback = feedbackFile ? await readFile(feedbackFile, 'utf8') : valueAfter(argv, '--feedback');
+        console.log(JSON.stringify(await requestSideTrack({ projectPath, step: 'chapter_revision', chapterNumber: Number(chapter), feedback }), null, 2));
+        return;
+    }
+    if (command === 'cross-review') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const start = valueAfter(argv, '--start');
+        const end = valueAfter(argv, '--end');
+        const range = start && end ? { start: Number(start), end: Number(end) } : undefined;
+        console.log(JSON.stringify(await requestSideTrack({ projectPath, step: 'cross_chapter_review', range }), null, 2));
+        return;
+    }
+    if (command === 'list') {
+        const outputDir = valueAfter(argv, '--output') || 'novels';
+        console.log(JSON.stringify(await listProjects({ workspaceRoot: cwd, outputDir }), null, 2));
+        return;
+    }
+    if (command === 'status') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        console.log(JSON.stringify(await getProjectStatus(projectPath), null, 2));
+        return;
+    }
+    if (command === 'retrieve') {
+        if (!projectPath)
+            throw new Error('Missing projectPath');
+        const query = valueAfter(argv, '--query');
+        if (!query)
+            throw new Error('Missing --query');
+        const topK = valueAfter(argv, '--top-k');
+        const start = valueAfter(argv, '--start');
+        const end = valueAfter(argv, '--end');
+        const typesArg = valueAfter(argv, '--types');
+        const types = typesArg ? typesArg.split(',') : undefined;
+        const hits = await retrieve(projectPath, query, {
+            topK: topK ? Number(topK) : undefined,
+            types,
+            chapterRange: start && end ? { start: Number(start), end: Number(end) } : undefined,
+        });
+        console.log(JSON.stringify({ query, hits }, null, 2));
+        return;
+    }
+    throw new Error('Usage: novelforge-agent start|list|status|next|submit|context|review|revise|cross-review|retrieve');
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runCli().catch((error) => {
+        console.error(error.message);
+        process.exitCode = 1;
+    });
+}

package/dist/src/core/contextBuilder.js

@@ -0,0 +1,128 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { chapterFileName, chapterReviewFileName, memoryFileName } from './fileNames.js';
+import { formatHits, retrieve } from './retrieval/index.js';
+async function readOptional(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function buildContext(input) {
+    const parts = [];
+    const metadata = await readOptional(join(input.projectPath, 'novel.json'));
+    const storyBible = await readOptional(join(input.projectPath, 'story-bible.md'));
+    const chaptersJson = await readOptional(join(input.projectPath, 'architecture/chapters.json'));
+    if (metadata)
+        parts.push(`## Novel Metadata\n${metadata}`);
+    if (storyBible)
+        parts.push(`## Story Bible\n${storyBible.slice(0, 4000)}`);
+    if (input.purpose === 'chapter_generation' && input.chapterNumber) {
+        let currentArchitectureForQuery;
+        if (chaptersJson) {
+            const chapters = JSON.parse(chaptersJson);
+            const chapter = chapters.find((item) => item.chapterNumber === input.chapterNumber);
+            if (chapter) {
+                currentArchitectureForQuery = chapter;
+                parts.push(`## Current Chapter Architecture\n${JSON.stringify(chapter, null, 2)}`);
+            }
+        }
+        if (input.chapterNumber > 1) {
+            const previous = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber - 1)));
+            const previousMemory = await readOptional(join(input.projectPath, 'memory', memoryFileName(input.chapterNumber - 1)));
+            if (previous)
+                parts.push(`## Previous Chapter Ending\n${previous.slice(-1600)}`);
+            if (previousMemory)
+                parts.push(`## Previous Chapter Memory\n${previousMemory}`);
+            const queryPieces = [];
+            if (currentArchitectureForQuery?.title)
+                queryPieces.push(currentArchitectureForQuery.title);
+            if (currentArchitectureForQuery?.summary)
+                queryPieces.push(currentArchitectureForQuery.summary);
+            if (currentArchitectureForQuery?.requiredBeats?.length) {
+                queryPieces.push(currentArchitectureForQuery.requiredBeats.join(' '));
+            }
+            const query = queryPieces.join(' ').trim();
+            if (query) {
+                const hits = await retrieve(input.projectPath, query, {
+                    topK: 5,
+                    chapterRange: { start: 1, end: input.chapterNumber - 1 },
+                });
+                const formatted = formatHits(hits);
+                if (formatted)
+                    parts.push(`## Retrieved Relevant Snippets (lexical, BM25-style)\n${formatted}`);
+            }
+        }
+    }
+    if (input.purpose === 'memory_extraction' && input.chapterNumber) {
+        const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber)));
+        if (chapter)
+            parts.push(`## Current Chapter\n${chapter}`);
+    }
+    if (input.purpose === 'continuity_review') {
+        if (chaptersJson)
+            parts.push(`## Chapter Architecture List\n${chaptersJson}`);
+        const memoryParts = [];
+        for (let i = 1; i <= 20; i += 1) {
+            const memory = await readOptional(join(input.projectPath, 'memory', memoryFileName(i)));
+            if (memory)
+                memoryParts.push(`### Chapter ${i}\n${memory}`);
+        }
+        if (memoryParts.length)
+            parts.push(`## Memory Cards\n${memoryParts.join('\n')}`);
+    }
+    if (input.purpose === 'chapter_review' && input.chapterNumber) {
+        if (chaptersJson) {
+            const chapters = JSON.parse(chaptersJson);
+            const arch = chapters.find((item) => item.chapterNumber === input.chapterNumber);
+            if (arch)
+                parts.push(`## Target Chapter Architecture\n${JSON.stringify(arch, null, 2)}`);
+        }
+        const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber)));
+        if (chapter)
+            parts.push(`## Chapter ${input.chapterNumber} Text\n${chapter}`);
+        if (input.chapterNumber > 1) {
+            const prevMemory = await readOptional(join(input.projectPath, 'memory', memoryFileName(input.chapterNumber - 1)));
+            if (prevMemory)
+                parts.push(`## Previous Chapter Memory\n${prevMemory}`);
+        }
+    }
+    if (input.purpose === 'revision' && input.chapterNumber) {
+        const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber)));
+        if (chapter)
+            parts.push(`## Current Chapter Text\n${chapter}`);
+        const review = await readOptional(join(input.projectPath, 'reviews/chapter', chapterReviewFileName(input.chapterNumber)));
+        if (review)
+            parts.push(`## Editor Review\n${review}`);
+        if (input.feedback)
+            parts.push(`## Additional Feedback\n${input.feedback}`);
+        if (input.chapterNumber > 1) {
+            const previous = await readOptional(join(input.projectPath, 'chapters', chapterFileName(input.chapterNumber - 1)));
+            if (previous)
+                parts.push(`## Previous Chapter Ending\n${previous.slice(-1600)}`);
+        }
+    }
+    if (input.purpose === 'cross_chapter_review' && input.range) {
+        if (chaptersJson)
+            parts.push(`## Chapter Architecture List\n${chaptersJson}`);
+        const memoryParts = [];
+        for (let i = input.range.start; i <= input.range.end; i += 1) {
+            const memory = await readOptional(join(input.projectPath, 'memory', memoryFileName(i)));
+            if (memory)
+                memoryParts.push(`### Chapter ${i} Memory\n${memory}`);
+        }
+        if (memoryParts.length)
+            parts.push(`## Memory Cards In Range\n${memoryParts.join('\n')}`);
+        const tailParts = [];
+        for (let i = input.range.start; i <= input.range.end; i += 1) {
+            const chapter = await readOptional(join(input.projectPath, 'chapters', chapterFileName(i)));
+            if (chapter)
+                tailParts.push(`### Chapter ${i} Last 800 Chars\n${chapter.slice(-800)}`);
+        }
+        if (tailParts.length)
+            parts.push(`## Chapter Tails\n${tailParts.join('\n')}`);
+    }
+    return parts.join('\n\n').trim();
+}

package/dist/src/core/fileNames.js

@@ -0,0 +1,41 @@
+const PINYIN_FALLBACK = {
+    星: 'xing',
+    火: 'huo',
+    长: 'chang',
+    夜: 'ye',
+};
+export function makeProjectSlug(title) {
+    const replaced = title
+        .trim()
+        .split('')
+        .map((char) => PINYIN_FALLBACK[char] || char)
+        .join('-')
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return replaced || `novel-${Date.now()}`;
+}
+export function padChapterNumber(chapterNumber) {
+    if (!Number.isInteger(chapterNumber) || chapterNumber <= 0) {
+        throw new Error(`Invalid chapter number: ${chapterNumber}`);
+    }
+    return String(chapterNumber).padStart(3, '0');
+}
+export function chapterFileName(chapterNumber) {
+    return `${padChapterNumber(chapterNumber)}.md`;
+}
+export function memoryFileName(chapterNumber) {
+    return `chapter-${padChapterNumber(chapterNumber)}.json`;
+}
+export function chapterReviewFileName(chapterNumber) {
+    return `chapter-${padChapterNumber(chapterNumber)}.json`;
+}
+export function crossChapterReviewFileName(start, end) {
+    return `cross-${padChapterNumber(start)}-${padChapterNumber(end)}.json`;
+}
+export function chapterVersionFileName(chapterNumber, timestamp) {
+    const safeTs = timestamp.replace(/[:.]/g, '-');
+    return `${padChapterNumber(chapterNumber)}.${safeTs}.md`;
+}

package/dist/src/core/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './schemas.js';
+export * from './fileNames.js';
+export * from './projectStore.js';
+export * from './workflow.js';
+export * from './contextBuilder.js';
+export * from './prompts.js';
+export * from './retrieval/index.js';
+export * from './projectDiscovery.js';