novelforge-agent 0.1.1 → 0.3.0

package/dist/src/core/steps/chapterReview.js

@@ -5,12 +5,37 @@ import { chapterReviewFileName } from '../fileNames.js';
 import { parseJson } from './types.js';
 export const chapterReviewHandler = async (state, content) => {
     const parsed = ChapterReviewSchema.parse(parseJson(content));
+    const hasFailedAcceptance = Object.values(parsed.acceptance).some((check) => check.status === 'fail');
     const target = state.pendingAction?.chapterNumber ?? parsed.chapterNumber;
     const relative = join('reviews/chapter', chapterReviewFileName(target));
     const path = await saveJsonFile(state.projectPath, relative, parsed);
+    if (state.pendingAction?.mode === 'side_track') {
+        return {
+            savedPaths: [path],
+            fileEntries: { [`review-chapter-${target}`]: relative },
+            next: { kind: 'sideTrackReturn' },
+        };
+    }
+    if (parsed.status === 'clean' && !hasFailedAcceptance) {
+        return {
+            savedPaths: [path],
+            fileEntries: { [`review-chapter-${target}`]: relative },
+            next: { kind: 'linear', nextStep: 'memory_card' },
+        };
+    }
     return {
         savedPaths: [path],
         fileEntries: { [`review-chapter-${target}`]: relative },
-        next: { kind: 'sideTrackReturn' },
+        next: {
+            kind: 'linear',
+            nextStep: 'chapter_revision',
+            statePatch: {
+                pendingAction: {
+                    step: 'chapter_revision',
+                    mode: 'gate',
+                    chapterNumber: target,
+                },
+            },
+        },
     };
 };

package/dist/src/core/steps/chapterRevision.js

@@ -12,6 +12,23 @@ export const chapterRevisionHandler = async (state, content) => {
     const savedPaths = archived ? [archived] : [];
     savedPaths.push(await saveMarkdownFile(state.projectPath, chapterRelative, content));
     await indexChapter(state.projectPath, target, content);
+    if (state.pendingAction?.mode === 'gate') {
+        return {
+            savedPaths,
+            fileEntries: { [`chapter-${target}`]: chapterRelative },
+            next: {
+                kind: 'linear',
+                nextStep: 'chapter_review',
+                statePatch: {
+                    pendingAction: {
+                        step: 'chapter_review',
+                        mode: 'gate',
+                        chapterNumber: target,
+                    },
+                },
+            },
+        };
+    }
     return {
         savedPaths,
         fileEntries: { [`chapter-${target}`]: chapterRelative },

package/dist/src/core/steps/index.js

@@ -1,3 +1,4 @@
+import { architectureExtensionHandler } from './architectureExtension.js';
 import { architectureHandler } from './architecture.js';
 import { chapterHandler } from './chapter.js';
 import { chapterReviewHandler } from './chapterReview.js';
@@ -6,11 +7,14 @@ import { continuityReviewHandler } from './continuityReview.js';
 import { crossChapterReviewHandler } from './crossChapterReview.js';
 import { memoryCardHandler } from './memoryCard.js';
 import { novelMetadataHandler } from './novelMetadata.js';
+import { styleGuideHandler } from './styleGuide.js';
 import { storyBibleHandler } from './storyBible.js';
 export const STEP_HANDLERS = {
     novel_metadata: novelMetadataHandler,
     story_bible: storyBibleHandler,
+    style_guide: styleGuideHandler,
     architecture: architectureHandler,
+    architecture_extension: architectureExtensionHandler,
     chapter: chapterHandler,
     memory_card: memoryCardHandler,
     continuity_review: continuityReviewHandler,

package/dist/src/core/steps/memoryCard.js

@@ -1,21 +1,46 @@
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { MemoryCardSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
 import { memoryFileName } from '../fileNames.js';
 import { indexMemoryCard } from '../retrieval/index.js';
+import { ingestMemoryCardThreads } from '../threadStore.js';
+import { applyCharacterUpdates } from '../characterStore.js';
 import { parseJson } from './types.js';
+async function maxPlannedChapter(projectPath) {
+    try {
+        const raw = await readFile(join(projectPath, 'architecture/chapters.json'), 'utf8');
+        const chapters = JSON.parse(raw);
+        return chapters.reduce((max, chapter) => {
+            const value = Number(chapter.chapterNumber);
+            return Number.isFinite(value) && value > max ? value : max;
+        }, 0);
+    }
+    catch {
+        return 0;
+    }
+}
 export const memoryCardHandler = async (state, content) => {
     const parsed = MemoryCardSchema.parse(parseJson(content));
     const relative = join('memory', memoryFileName(state.currentChapter));
     const path = await saveJsonFile(state.projectPath, relative, parsed);
     await indexMemoryCard(state.projectPath, state.currentChapter, parsed);
+    await ingestMemoryCardThreads(state.projectPath, state.currentChapter, parsed.threadActions);
+    await applyCharacterUpdates(state.projectPath, state.currentChapter, parsed.characterUpdates);
     const nextChapter = state.currentChapter + 1;
+    const plannedTotalChapters = state.plannedTotalChapters ?? state.targetChapters;
+    const plannedMax = await maxPlannedChapter(state.projectPath);
+    const nextStep = nextChapter > plannedTotalChapters
+        ? 'continuity_review'
+        : nextChapter > plannedMax
+            ? 'architecture_extension'
+            : 'chapter';
     return {
         savedPaths: [path],
         fileEntries: { [`memory-${state.currentChapter}`]: relative },
         next: {
             kind: 'linear',
-            nextStep: nextChapter > state.targetChapters ? 'continuity_review' : 'chapter',
+            nextStep,
             statePatch: { currentChapter: nextChapter },
         },
     };

package/dist/src/core/steps/novelMetadata.js

@@ -1,12 +1,14 @@
 import { NovelMetadataSchema } from '../schemas.js';
 import { saveJsonFile } from '../projectStore.js';
+import { initializeCharacterStates } from '../characterStore.js';
 import { parseJson } from './types.js';
 export const novelMetadataHandler = 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);
     return {
-        savedPaths: [path],
-        fileEntries: { novel: 'novel.json' },
+        savedPaths: [path, charactersPath],
+        fileEntries: { novel: 'novel.json', characters: 'characters.json' },
         next: { kind: 'linear', nextStep: 'story_bible' },
     };
 };

package/dist/src/core/steps/storyBible.js

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

package/dist/src/core/steps/styleGuide.js

@@ -0,0 +1,12 @@
+import { StyleGuideSchema } from '../schemas.js';
+import { saveJsonFile } from '../projectStore.js';
+import { parseJson } from './types.js';
+export const styleGuideHandler = 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/dist/src/core/threadStore.js

@@ -0,0 +1,150 @@
+import { randomBytes } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const THREADS_FILE = 'threads.json';
+export async function loadThreads(projectPath) {
+    try {
+        const raw = await readFile(join(projectPath, THREADS_FILE), 'utf8');
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.threads) ? parsed.threads : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveThreads(projectPath, threads) {
+    const fullPath = join(projectPath, THREADS_FILE);
+    const bundle = { threads };
+    await writeFile(fullPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf8');
+    return fullPath;
+}
+function newThreadId(existing) {
+    let candidate = `t_${randomBytes(3).toString('hex')}`;
+    while (existing.has(candidate)) {
+        candidate = `t_${randomBytes(3).toString('hex')}`;
+    }
+    return candidate;
+}
+function findByDescription(threads, description) {
+    const target = description.trim();
+    return threads.find((t) => t.description.trim() === target);
+}
+/**
+ * Apply the threadActions emitted by a memory_card for chapter `chapterNumber`.
+ * Behavior:
+ *  - 'plant'   → create new thread (or reuse if identical description already planted)
+ *  - 'build'   → mark existing thread status = 'building', bump lastTouchedAt
+ *  - 'pay'     → mark existing thread status = 'paid', set paidOffAt
+ *  - 'drop'    → mark existing thread status = 'dropped', set droppedAt
+ *  Unknown threadIds for non-plant actions are tolerated (a new thread is created and marked appropriately, so we never lose user intent).
+ */
+export function applyThreadActions(existing, chapterNumber, actions) {
+    if (!actions || !actions.length)
+        return existing;
+    const next = existing.map((t) => ({ ...t }));
+    const byId = new Map(next.map((t) => [t.id, t]));
+    const usedIds = new Set(next.map((t) => t.id));
+    for (const action of actions) {
+        if (action.kind === 'plant') {
+            const dup = findByDescription(next, action.description);
+            if (dup) {
+                dup.lastTouchedAt = Math.max(dup.lastTouchedAt, chapterNumber);
+                continue;
+            }
+            const id = action.threadId && !usedIds.has(action.threadId)
+                ? action.threadId
+                : newThreadId(usedIds);
+            usedIds.add(id);
+            const planted = {
+                id,
+                description: action.description.trim(),
+                status: 'planted',
+                plantedAt: chapterNumber,
+                lastTouchedAt: chapterNumber,
+            };
+            next.push(planted);
+            byId.set(id, planted);
+            continue;
+        }
+        // build / pay / drop need an existing thread
+        let target = action.threadId ? byId.get(action.threadId) : undefined;
+        if (!target) {
+            target = findByDescription(next, action.description);
+        }
+        if (!target) {
+            // Create a placeholder so the user intent is captured; mark planted+touched on this chapter
+            const id = newThreadId(usedIds);
+            usedIds.add(id);
+            target = {
+                id,
+                description: action.description.trim(),
+                status: 'planted',
+                plantedAt: chapterNumber,
+                lastTouchedAt: chapterNumber,
+                notes: `Auto-created from a ${action.kind} action without a known threadId.`,
+            };
+            next.push(target);
+            byId.set(id, target);
+        }
+        target.lastTouchedAt = chapterNumber;
+        if (action.kind === 'build') {
+            target.status = 'building';
+        }
+        else if (action.kind === 'pay') {
+            target.status = 'paid';
+            target.paidOffAt = chapterNumber;
+        }
+        else if (action.kind === 'drop') {
+            target.status = 'dropped';
+            target.droppedAt = chapterNumber;
+        }
+    }
+    return next;
+}
+export function activeThreads(threads) {
+    return threads.filter((t) => t.status === 'planted' || t.status === 'building');
+}
+export async function ingestMemoryCardThreads(projectPath, chapterNumber, actions) {
+    if (!actions || !actions.length)
+        return loadThreads(projectPath);
+    const existing = await loadThreads(projectPath);
+    const next = applyThreadActions(existing, chapterNumber, actions);
+    await saveThreads(projectPath, next);
+    return next;
+}
+export async function updateThread(projectPath, id, patch) {
+    const existing = await loadThreads(projectPath);
+    const target = existing.find((t) => t.id === id);
+    if (!target)
+        throw new Error(`Thread not found: ${id}`);
+    if (patch.status)
+        target.status = patch.status;
+    if (patch.description)
+        target.description = patch.description.trim();
+    if (Object.prototype.hasOwnProperty.call(patch, 'plannedPayoffAt')) {
+        if (patch.plannedPayoffAt === null)
+            delete target.plannedPayoffAt;
+        else if (typeof patch.plannedPayoffAt === 'number')
+            target.plannedPayoffAt = patch.plannedPayoffAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'paidOffAt')) {
+        if (patch.paidOffAt === null)
+            delete target.paidOffAt;
+        else if (typeof patch.paidOffAt === 'number')
+            target.paidOffAt = patch.paidOffAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'droppedAt')) {
+        if (patch.droppedAt === null)
+            delete target.droppedAt;
+        else if (typeof patch.droppedAt === 'number')
+            target.droppedAt = patch.droppedAt;
+    }
+    if (Object.prototype.hasOwnProperty.call(patch, 'notes')) {
+        if (patch.notes === null)
+            delete target.notes;
+        else if (typeof patch.notes === 'string')
+            target.notes = patch.notes;
+    }
+    await saveThreads(projectPath, existing);
+    return target;
+}

package/dist/src/core/workflow.js

@@ -5,6 +5,8 @@ import { buildPromptForStep } from './prompts.js';
 import { loadState, saveJsonFile, saveRecoveryFile, saveState } from './projectStore.js';
 import { STEP_HANDLERS } from './steps/index.js';
 const CONTEXT_RECIPES = {
+    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' }),
@@ -83,19 +85,19 @@ function buildPendingAction(state, input) {
         case 'chapter_review': {
             if (!input.chapterNumber)
                 throw new Error('chapter_review requires chapterNumber');
-            return { step: 'chapter_review', chapterNumber: input.chapterNumber };
+            return { step: 'chapter_review', mode: 'side_track', chapterNumber: input.chapterNumber };
         }
         case 'chapter_revision': {
             if (!input.chapterNumber)
                 throw new Error('chapter_revision requires chapterNumber');
-            return { step: 'chapter_revision', chapterNumber: input.chapterNumber, feedback: input.feedback };
+            return { step: 'chapter_revision', mode: 'side_track', chapterNumber: input.chapterNumber, feedback: input.feedback };
         }
         case 'cross_chapter_review': {
             const max = maxExistingChapter(state);
             const range = input.range ?? { start: 1, end: max || state.currentChapter };
             if (range.start < 1 || range.end < range.start)
                 throw new Error('Invalid range');
-            return { step: 'cross_chapter_review', range };
+            return { step: 'cross_chapter_review', mode: 'side_track', range };
         }
         default:
             throw new Error(`Unknown side-track step: ${input.step}`);