novelforge-agent 0.2.0 → 0.4.0

package/src/core/steps/novelMetadata.ts

@@ -1,15 +1,61 @@
+import { access, rename } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
 import { NovelMetadataSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
 import { initializeCharacterStates } from '../characterStore.js';
+import { makeProjectSlug } from '../fileNames.js';
 import { StepHandler, parseJson } from './types.js';
 
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function uniqueProjectPath(parentDir: string, baseName: string, currentPath: string): Promise<string> {
+  let candidate = join(parentDir, baseName);
+  if (candidate === currentPath || !(await pathExists(candidate))) return candidate;
+
+  for (let index = 2; index < 100; index += 1) {
+    candidate = join(parentDir, `${baseName}-${index}`);
+    if (candidate === currentPath || !(await pathExists(candidate))) return candidate;
+  }
+
+  throw new Error(`Unable to find available project directory for ${baseName}`);
+}
+
+async function renameProjectForTitle(projectPath: string, title: string): Promise<string> {
+  const parentDir = dirname(projectPath);
+  const currentName = basename(projectPath);
+  const suffix = currentName.match(/-([a-f0-9]{6})$/i)?.[1];
+  const titleSlug = makeProjectSlug(title);
+  const nextName = suffix ? `${titleSlug}-${suffix}` : titleSlug;
+  if (nextName === currentName) return projectPath;
+
+  const nextPath = await uniqueProjectPath(parentDir, nextName, projectPath);
+  if (nextPath === projectPath) return projectPath;
+  await rename(projectPath, nextPath);
+  return nextPath;
+}
+
 export const novelMetadataHandler: StepHandler = async (state, content) => {
   const parsed = NovelMetadataSchema.parse(parseJson(content));
   const path = await saveJsonFile(state.projectPath, 'novel.json', parsed);
   const charactersPath = await initializeCharacterStates(state.projectPath, parsed.coreCast);
+  const projectPath = await renameProjectForTitle(state.projectPath, parsed.title);
   return {
-    savedPaths: [path, charactersPath],
+    savedPaths: [
+      projectPath === state.projectPath ? path : join(projectPath, 'novel.json'),
+      projectPath === state.projectPath ? charactersPath : join(projectPath, 'characters.json'),
+    ],
     fileEntries: { novel: 'novel.json', characters: 'characters.json' },
-    next: { kind: 'linear', nextStep: 'story_bible' },
+    next: {
+      kind: 'linear',
+      nextStep: 'story_bible',
+      statePatch: { projectPath },
+    },
   };
 };

package/src/core/steps/storyBible.ts

@@ -9,6 +9,6 @@ export const storyBibleHandler: StepHandler = async (state, content) => {
   return {
     savedPaths: [path],
     fileEntries: { storyBible: 'story-bible.md' },
-    next: { kind: 'linear', nextStep: 'architecture' },
+    next: { kind: 'linear', nextStep: 'style_guide' },
   };
 };

package/src/core/steps/styleGuide.ts

@@ -0,0 +1,13 @@
+import { StyleGuideSchema } from '../schemas.js';
+import { saveJsonFile } from '../projectStore.js';
+import { StepHandler, parseJson } from './types.js';
+
+export const styleGuideHandler: StepHandler = async (state, content) => {
+  const parsed = StyleGuideSchema.parse(parseJson(content));
+  const path = await saveJsonFile(state.projectPath, 'style-guide.json', parsed);
+  return {
+    savedPaths: [path],
+    fileEntries: { styleGuide: 'style-guide.json' },
+    next: { kind: 'linear', nextStep: 'architecture' },
+  };
+};

package/src/core/types.ts

@@ -1,7 +1,9 @@
 export type WorkflowStep =
   | 'novel_metadata'
   | 'story_bible'
+  | 'style_guide'
   | 'architecture'
+  | 'architecture_extension'
   | 'chapter'
   | 'memory_card'
   | 'continuity_review'
@@ -44,6 +46,7 @@ export interface ChapterAcceptanceGate {
   characterProgress: ChapterAcceptanceCheck;
   foreshadowProgress: ChapterAcceptanceCheck;
   storyBibleConsistency: ChapterAcceptanceCheck;
+  proseRhythm: ChapterAcceptanceCheck;
   endingHook: ChapterAcceptanceCheck;
   repetition: ChapterAcceptanceCheck;
 }
@@ -82,6 +85,23 @@ export interface NovelMetadata {
   coreCast: CoreCastMember[];
 }
 
+export interface StyleGuide {
+  narrativeVoice: string;
+  pacing: string;
+  diction: string;
+  dialogueRules: string[];
+  prohibitedPatterns: string[];
+  proseRhythm: {
+    sentenceRhythm: string;
+    paragraphing: string;
+    interiorityMode: string;
+    emphasisBudget: string;
+    antiPatterns: string[];
+  };
+  sampleParagraph: string;
+  consistencyChecks: string[];
+}
+
 export interface VolumeArchitecture {
   id: string;
   title: string;
@@ -121,6 +141,13 @@ export interface ArchitecturePayload {
   chapters: ChapterArchitecture[];
 }
 
+export interface ArchitectureExtensionPayload {
+  fullUpdate?: string;
+  volumes?: VolumeArchitecture[];
+  volumePacing?: VolumePacingBoard[];
+  chapters: ChapterArchitecture[];
+}
+
 export type ThreadStatus = 'planted' | 'building' | 'paid' | 'dropped';
 
 export type ThreadActionKind = 'plant' | 'build' | 'pay' | 'drop';
@@ -196,7 +223,12 @@ export interface AgentState {
   projectPath: string;
   initialPrompt: string;
   language: 'zh-CN' | 'en-US';
+  /**
+   * Number of chapters to plan in each architecture batch.
+   * The whole-book target lives in plannedTotalChapters.
+   */
   targetChapters: number;
+  plannedTotalChapters: number;
   currentStep: WorkflowStep;
   currentChapter: number;
   completedSteps: WorkflowStep[];

package/src/core/workflow.ts

@@ -37,6 +37,8 @@ export interface RequestSideTrackInput {
 type ContextRecipe = (state: AgentState) => Omit<BuildContextInput, 'projectPath'>;
 
 const CONTEXT_RECIPES: Partial<Record<WorkflowStep, ContextRecipe>> = {
+  style_guide: () => ({ purpose: 'style_guide' }),
+  architecture_extension: (s) => ({ purpose: 'architecture_extension', chapterNumber: s.currentChapter }),
   chapter: (s) => ({ purpose: 'chapter_generation', chapterNumber: s.currentChapter }),
   memory_card: (s) => ({ purpose: 'memory_extraction', chapterNumber: s.currentChapter }),
   continuity_review: () => ({ purpose: 'continuity_review' }),

package/src/mcp/tools.ts

@@ -1,6 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import {
   amendStoryBible,
   assertProjectPath,
@@ -21,7 +23,24 @@ import {
   updateThread,
 } from '../core/index.js';
 
-const MCP_SERVER_VERSION = '0.2.0';
+function packageVersion(): string {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    try {
+      const raw = readFileSync(join(dir, 'package.json'), 'utf8');
+      const parsed = JSON.parse(raw) as { version?: unknown };
+      if (typeof parsed.version === 'string' && parsed.version) return parsed.version;
+    } catch {
+      // keep walking upward until the package root is found
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) return '0.0.0';
+    dir = parent;
+  }
+}
+
+const MCP_SERVER_VERSION = packageVersion();
 
 export interface CreateNovelAgentServerOptions {
   workspaceRoot: string;
@@ -59,15 +78,17 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
       prompt: z.string().min(1),
       language: z.enum(['zh-CN', 'en-US']).default('zh-CN'),
       outputDir: z.string().default('novels'),
-      targetChapters: z.number().int().positive().default(3),
+      targetChapters: z.number().int().positive().default(5),
+      plannedTotalChapters: z.number().int().positive().default(12),
     },
-    async ({ prompt, language, outputDir, targetChapters }) => {
+    async ({ prompt, language, outputDir, targetChapters, plannedTotalChapters }) => {
       const result = await createProject({
         workspaceRoot: options.workspaceRoot,
         prompt,
         language,
         outputDir,
         targetChapters,
+        plannedTotalChapters,
       });
       return textResult({ state: result.state, next: await getNextStep(result.state.projectPath) });
     }
@@ -105,7 +126,9 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
       step: z.enum([
         'novel_metadata',
         'story_bible',
+        'style_guide',
         'architecture',
+        'architecture_extension',
         'chapter',
         'memory_card',
         'continuity_review',
@@ -127,6 +150,8 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
       projectPath: z.string().min(1),
       purpose: z.enum([
         'chapter_generation',
+        'style_guide',
+        'architecture_extension',
         'memory_extraction',
         'continuity_review',
         'revision',
@@ -336,6 +361,7 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
       step: z.enum([
         'novel_metadata',
         'story_bible',
+        'style_guide',
         'architecture',
         'chapter',
         'memory_card',
@@ -354,14 +380,15 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
     'Start a brand new novel project under the configured workspace.',
     {
       prompt: z.string().describe('User idea / premise / genre, in any language.'),
-      chapters: z.string().optional().describe('Target number of chapters as a string. Defaults to 5.'),
+      chapters: z.string().optional().describe('Planning batch size as a string. Defaults to 5.'),
+      totalChapters: z.string().optional().describe('Whole-book target chapter count as a string. Defaults to 12.'),
     },
-    ({ prompt, chapters }) => ({
+    ({ prompt, chapters, totalChapters }) => ({
       messages: [{
         role: 'user' as const,
         content: {
           type: 'text' as const,
-          text: `Use the novelforge MCP server. Call start_novel_project with prompt="${prompt}", targetChapters=${chapters ?? '5'}, then enter the autonomous loop: read next.instruction, generate the requested content, call submit_step_result, repeat until currentStep is "complete". Show me the projectPath after start_novel_project returns.`,
+          text: `Use the novelforge MCP server. Call start_novel_project with prompt="${prompt}", targetChapters=${chapters ?? '5'}, plannedTotalChapters=${totalChapters ?? '12'}, then enter the autonomous loop: read next.instruction, generate the requested content, call submit_step_result, repeat until currentStep is "complete". Show me the projectPath after start_novel_project returns.`,
         },
       }],
     })
@@ -393,7 +420,7 @@ export function createNovelAgentServer(options: CreateNovelAgentServerOptions):
         role: 'user' as const,
         content: {
           type: 'text' as const,
-          text: 'Use the novelforge MCP server: call list_projects with no arguments. Show me the result in a compact table (title, currentStep, chaptersWritten/targetChapters, updatedAt, projectPath).',
+          text: 'Use the novelforge MCP server: call list_projects with no arguments. Show me the result in a compact table (title, currentStep, chaptersWritten/plannedTotalChapters, updatedAt, projectPath).',
         },
       }],
     })