@narrative-os/engine 0.1.0

package/dist/agents/tensionController.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tensionController = exports.TensionController = void 0;
+exports.calculateTargetTension = calculateTargetTension;
+exports.calculateNextChapterTension = calculateNextChapterTension;
+exports.analyzeTension = analyzeTension;
+exports.generateTensionGuidance = generateTensionGuidance;
+exports.formatTensionForPrompt = formatTensionForPrompt;
+exports.estimateTensionFromChapter = estimateTensionFromChapter;
+/**
+ * Calculate target tension using parabolic curve
+ * Formula: targetTension = 4 * progress * (1 - progress)
+ *
+ * This creates a natural dramatic arc:
+ * - Chapter 0: 0% tension (setup)
+ * - Middle chapters: ~100% tension (peak drama)
+ * - Final chapter: 0% tension (resolution)
+ */
+function calculateTargetTension(currentChapter, totalChapters) {
+    if (totalChapters <= 1)
+        return 0.5;
+    // Progress from 0 to 1
+    const progress = (currentChapter - 1) / (totalChapters - 1);
+    // Parabolic curve: 4 * x * (1 - x)
+    // Peak at 0.5 (middle of story)
+    const targetTension = 4 * progress * (1 - progress);
+    // Round to 2 decimal places
+    return Math.round(targetTension * 100) / 100;
+}
+/**
+ * Calculate tension for next chapter based on ideal arc
+ */
+function calculateNextChapterTension(currentChapter, totalChapters) {
+    return calculateTargetTension(currentChapter + 1, totalChapters);
+}
+/**
+ * Analyze current tension vs target and provide guidance
+ */
+function analyzeTension(storyState, structuredState) {
+    const targetTension = calculateTargetTension(storyState.currentChapter, storyState.totalChapters);
+    const currentTension = structuredState.tension;
+    const tensionGap = targetTension - currentTension;
+    let recommendedAction;
+    let reasoning;
+    if (storyState.currentChapter === storyState.totalChapters) {
+        recommendedAction = 'resolve';
+        reasoning = 'Final chapter - bring tensions to resolution';
+    }
+    else if (tensionGap > 0.2) {
+        recommendedAction = 'escalate';
+        reasoning = `Tension is ${(tensionGap * 100).toFixed(0)}% below target. Escalate conflict.`;
+    }
+    else if (tensionGap < -0.15) {
+        recommendedAction = 'maintain';
+        reasoning = `Tension is ${(Math.abs(tensionGap) * 100).toFixed(0)}% above target. Allow breathing room.`;
+    }
+    else if (targetTension > 0.85) {
+        recommendedAction = 'climax';
+        reasoning = 'Near peak tension - build toward climax';
+    }
+    else {
+        recommendedAction = 'maintain';
+        reasoning = 'Tension is on track with target arc';
+    }
+    return {
+        currentTension,
+        targetTension,
+        tensionGap,
+        recommendedAction,
+        reasoning,
+    };
+}
+/**
+ * Generate tension guidance for the writer
+ */
+function generateTensionGuidance(analysis, storyState) {
+    const { targetTension, recommendedAction } = analysis;
+    let guidance;
+    let sceneTypes;
+    let pacingNotes;
+    switch (recommendedAction) {
+        case 'escalate':
+            guidance = 'Increase dramatic tension. Introduce complications, raise stakes, or deepen conflicts.';
+            sceneTypes = ['confrontation', 'discovery', 'setback', 'danger'];
+            pacingNotes = 'Faster pace, shorter scenes, more action/dialogue';
+            break;
+        case 'maintain':
+            guidance = 'Maintain current tension level. Balance action with character moments.';
+            sceneTypes = ['development', 'interaction', 'preparation', 'reflection'];
+            pacingNotes = 'Moderate pace, mix of action and quiet moments';
+            break;
+        case 'resolve':
+            guidance = 'Begin resolving tensions. Answer questions, conclude arcs, provide closure.';
+            sceneTypes = ['resolution', 'revelation', 'farewell', 'new beginning'];
+            pacingNotes = 'Slower pace, focus on emotional satisfaction';
+            break;
+        case 'climax':
+            guidance = 'Build toward peak tension. Maximum stakes, critical decisions, turning points.';
+            sceneTypes = ['climax', 'showdown', 'revelation', 'sacrifice'];
+            pacingNotes = 'Fastest pace, continuous escalation, no relief';
+            break;
+        default:
+            guidance = 'Follow the natural flow of the story.';
+            sceneTypes = ['mixed'];
+            pacingNotes = 'Balanced pacing';
+    }
+    return {
+        targetTension,
+        guidance,
+        sceneTypes,
+        pacingNotes,
+    };
+}
+/**
+ * Format tension guidance for writer prompt
+ */
+function formatTensionForPrompt(guidance) {
+    const tensionPercent = Math.round(guidance.targetTension * 100);
+    return `## Tension Guidance
+
+**Target Tension Level:** ${tensionPercent}%
+
+**Guidance:** ${guidance.guidance}
+
+**Recommended Scene Types:** ${guidance.sceneTypes.join(', ')}
+
+**Pacing Notes:** ${guidance.pacingNotes}
+`;
+}
+/**
+ * Calculate tension based on chapter content analysis
+ * This is a heuristic for estimating tension from text
+ */
+function estimateTensionFromChapter(chapter) {
+    const content = chapter.content.toLowerCase();
+    // Tension indicators
+    const tensionWords = [
+        'fear', 'danger', 'threat', 'attack', 'fight', 'battle',
+        'scream', 'cry', 'panic', 'terror', 'horror',
+        'chase', 'escape', 'hide', 'run', 'flee',
+        'discover', 'reveal', 'secret', 'mystery', 'truth',
+        'confront', 'accuse', 'blame', 'angry', 'furious',
+        'worry', 'anxious', 'nervous', 'tense', 'stress',
+        'urgent', 'emergency', 'crisis', 'critical', 'desperate',
+    ];
+    const calmWords = [
+        'peace', 'calm', 'quiet', 'relax', 'rest',
+        'happy', 'joy', 'laugh', 'smile', 'comfort',
+        'safe', 'secure', 'peaceful', 'tranquil', 'serene',
+    ];
+    let tensionScore = 0.5; // baseline
+    // Count tension indicators
+    for (const word of tensionWords) {
+        const count = (content.match(new RegExp(word, 'g')) || []).length;
+        tensionScore += count * 0.02;
+    }
+    // Subtract calm indicators
+    for (const word of calmWords) {
+        const count = (content.match(new RegExp(word, 'g')) || []).length;
+        tensionScore -= count * 0.015;
+    }
+    // Clamp between 0 and 1
+    return Math.max(0, Math.min(1, Math.round(tensionScore * 100) / 100));
+}
+/**
+ * TensionController class for managing story tension
+ */
+class TensionController {
+    /**
+     * Analyze current story state and provide tension guidance
+     */
+    analyze(storyState, structuredState) {
+        return analyzeTension(storyState, structuredState);
+    }
+    /**
+     * Generate guidance for the next chapter
+     */
+    generateGuidance(storyState, structuredState) {
+        const analysis = this.analyze(storyState, structuredState);
+        return generateTensionGuidance(analysis, storyState);
+    }
+    /**
+     * Calculate what the tension should be for a specific chapter
+     */
+    calculateTarget(chapterNumber, totalChapters) {
+        return calculateTargetTension(chapterNumber, totalChapters);
+    }
+    /**
+     * Estimate tension from chapter content
+     */
+    estimateFromContent(chapter) {
+        return estimateTensionFromChapter(chapter);
+    }
+}
+exports.TensionController = TensionController;
+exports.tensionController = new TensionController();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tensionController.js","sourceRoot":"","sources":["../../src/agents/tensionController.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Chapter, StoryBible, StoryState } from '../types/index.js';\r\nimport type { StoryStructuredState } from '../story/structuredState.js';\r\n\r\nexport interface TensionAnalysis {\r\n  currentTension: number;\r\n  targetTension: number;\r\n  tensionGap: number; // positive = need to increase, negative = need to decrease\r\n  recommendedAction: 'escalate' | 'maintain' | 'resolve' | 'climax';\r\n  reasoning: string;\r\n}\r\n\r\nexport interface TensionGuidance {\r\n  targetTension: number;\r\n  guidance: string;\r\n  sceneTypes: string[];\r\n  pacingNotes: string;\r\n}\r\n\r\n/**\r\n * Calculate target tension using parabolic curve\r\n * Formula: targetTension = 4 * progress * (1 - progress)\r\n * \r\n * This creates a natural dramatic arc:\r\n * - Chapter 0: 0% tension (setup)\r\n * - Middle chapters: ~100% tension (peak drama)\r\n * - Final chapter: 0% tension (resolution)\r\n */\r\nexport function calculateTargetTension(\r\n  currentChapter: number,\r\n  totalChapters: number\r\n): number {\r\n  if (totalChapters <= 1) return 0.5;\r\n  \r\n  // Progress from 0 to 1\r\n  const progress = (currentChapter - 1) / (totalChapters - 1);\r\n  \r\n  // Parabolic curve: 4 * x * (1 - x)\r\n  // Peak at 0.5 (middle of story)\r\n  const targetTension = 4 * progress * (1 - progress);\r\n  \r\n  // Round to 2 decimal places\r\n  return Math.round(targetTension * 100) / 100;\r\n}\r\n\r\n/**\r\n * Calculate tension for next chapter based on ideal arc\r\n */\r\nexport function calculateNextChapterTension(\r\n  currentChapter: number,\r\n  totalChapters: number\r\n): number {\r\n  return calculateTargetTension(currentChapter + 1, totalChapters);\r\n}\r\n\r\n/**\r\n * Analyze current tension vs target and provide guidance\r\n */\r\nexport function analyzeTension(\r\n  storyState: StoryState,\r\n  structuredState: StoryStructuredState\r\n): TensionAnalysis {\r\n  const targetTension = calculateTargetTension(\r\n    storyState.currentChapter,\r\n    storyState.totalChapters\r\n  );\r\n  \r\n  const currentTension = structuredState.tension;\r\n  const tensionGap = targetTension - currentTension;\r\n  \r\n  let recommendedAction: TensionAnalysis['recommendedAction'];\r\n  let reasoning: string;\r\n  \r\n  if (storyState.currentChapter === storyState.totalChapters) {\r\n    recommendedAction = 'resolve';\r\n    reasoning = 'Final chapter - bring tensions to resolution';\r\n  } else if (tensionGap > 0.2) {\r\n    recommendedAction = 'escalate';\r\n    reasoning = `Tension is ${(tensionGap * 100).toFixed(0)}% below target. Escalate conflict.`;\r\n  } else if (tensionGap < -0.15) {\r\n    recommendedAction = 'maintain';\r\n    reasoning = `Tension is ${(Math.abs(tensionGap) * 100).toFixed(0)}% above target. Allow breathing room.`;\r\n  } else if (targetTension > 0.85) {\r\n    recommendedAction = 'climax';\r\n    reasoning = 'Near peak tension - build toward climax';\r\n  } else {\r\n    recommendedAction = 'maintain';\r\n    reasoning = 'Tension is on track with target arc';\r\n  }\r\n  \r\n  return {\r\n    currentTension,\r\n    targetTension,\r\n    tensionGap,\r\n    recommendedAction,\r\n    reasoning,\r\n  };\r\n}\r\n\r\n/**\r\n * Generate tension guidance for the writer\r\n */\r\nexport function generateTensionGuidance(\r\n  analysis: TensionAnalysis,\r\n  storyState: StoryState\r\n): TensionGuidance {\r\n  const { targetTension, recommendedAction } = analysis;\r\n  \r\n  let guidance: string;\r\n  let sceneTypes: string[];\r\n  let pacingNotes: string;\r\n  \r\n  switch (recommendedAction) {\r\n    case 'escalate':\r\n      guidance = 'Increase dramatic tension. Introduce complications, raise stakes, or deepen conflicts.';\r\n      sceneTypes = ['confrontation', 'discovery', 'setback', 'danger'];\r\n      pacingNotes = 'Faster pace, shorter scenes, more action/dialogue';\r\n      break;\r\n      \r\n    case 'maintain':\r\n      guidance = 'Maintain current tension level. Balance action with character moments.';\r\n      sceneTypes = ['development', 'interaction', 'preparation', 'reflection'];\r\n      pacingNotes = 'Moderate pace, mix of action and quiet moments';\r\n      break;\r\n      \r\n    case 'resolve':\r\n      guidance = 'Begin resolving tensions. Answer questions, conclude arcs, provide closure.';\r\n      sceneTypes = ['resolution', 'revelation', 'farewell', 'new beginning'];\r\n      pacingNotes = 'Slower pace, focus on emotional satisfaction';\r\n      break;\r\n      \r\n    case 'climax':\r\n      guidance = 'Build toward peak tension. Maximum stakes, critical decisions, turning points.';\r\n      sceneTypes = ['climax', 'showdown', 'revelation', 'sacrifice'];\r\n      pacingNotes = 'Fastest pace, continuous escalation, no relief';\r\n      break;\r\n      \r\n    default:\r\n      guidance = 'Follow the natural flow of the story.';\r\n      sceneTypes = ['mixed'];\r\n      pacingNotes = 'Balanced pacing';\r\n  }\r\n  \r\n  return {\r\n    targetTension,\r\n    guidance,\r\n    sceneTypes,\r\n    pacingNotes,\r\n  };\r\n}\r\n\r\n/**\r\n * Format tension guidance for writer prompt\r\n */\r\nexport function formatTensionForPrompt(guidance: TensionGuidance): string {\r\n  const tensionPercent = Math.round(guidance.targetTension * 100);\r\n  \r\n  return `## Tension Guidance\r\n\r\n**Target Tension Level:** ${tensionPercent}%\r\n\r\n**Guidance:** ${guidance.guidance}\r\n\r\n**Recommended Scene Types:** ${guidance.sceneTypes.join(', ')}\r\n\r\n**Pacing Notes:** ${guidance.pacingNotes}\r\n`;\r\n}\r\n\r\n/**\r\n * Calculate tension based on chapter content analysis\r\n * This is a heuristic for estimating tension from text\r\n */\r\nexport function estimateTensionFromChapter(chapter: Chapter): number {\r\n  const content = chapter.content.toLowerCase();\r\n  \r\n  // Tension indicators\r\n  const tensionWords = [\r\n    'fear', 'danger', 'threat', 'attack', 'fight', 'battle',\r\n    'scream', 'cry', 'panic', 'terror', 'horror',\r\n    'chase', 'escape', 'hide', 'run', 'flee',\r\n    'discover', 'reveal', 'secret', 'mystery', 'truth',\r\n    'confront', 'accuse', 'blame', 'angry', 'furious',\r\n    'worry', 'anxious', 'nervous', 'tense', 'stress',\r\n    'urgent', 'emergency', 'crisis', 'critical', 'desperate',\r\n  ];\r\n  \r\n  const calmWords = [\r\n    'peace', 'calm', 'quiet', 'relax', 'rest',\r\n    'happy', 'joy', 'laugh', 'smile', 'comfort',\r\n    'safe', 'secure', 'peaceful', 'tranquil', 'serene',\r\n  ];\r\n  \r\n  let tensionScore = 0.5; // baseline\r\n  \r\n  // Count tension indicators\r\n  for (const word of tensionWords) {\r\n    const count = (content.match(new RegExp(word, 'g')) || []).length;\r\n    tensionScore += count * 0.02;\r\n  }\r\n  \r\n  // Subtract calm indicators\r\n  for (const word of calmWords) {\r\n    const count = (content.match(new RegExp(word, 'g')) || []).length;\r\n    tensionScore -= count * 0.015;\r\n  }\r\n  \r\n  // Clamp between 0 and 1\r\n  return Math.max(0, Math.min(1, Math.round(tensionScore * 100) / 100));\r\n}\r\n\r\n/**\r\n * TensionController class for managing story tension\r\n */\r\nexport class TensionController {\r\n  /**\r\n   * Analyze current story state and provide tension guidance\r\n   */\r\n  analyze(\r\n    storyState: StoryState,\r\n    structuredState: StoryStructuredState\r\n  ): TensionAnalysis {\r\n    return analyzeTension(storyState, structuredState);\r\n  }\r\n  \r\n  /**\r\n   * Generate guidance for the next chapter\r\n   */\r\n  generateGuidance(\r\n    storyState: StoryState,\r\n    structuredState: StoryStructuredState\r\n  ): TensionGuidance {\r\n    const analysis = this.analyze(storyState, structuredState);\r\n    return generateTensionGuidance(analysis, storyState);\r\n  }\r\n  \r\n  /**\r\n   * Calculate what the tension should be for a specific chapter\r\n   */\r\n  calculateTarget(chapterNumber: number, totalChapters: number): number {\r\n    return calculateTargetTension(chapterNumber, totalChapters);\r\n  }\r\n  \r\n  /**\r\n   * Estimate tension from chapter content\r\n   */\r\n  estimateFromContent(chapter: Chapter): number {\r\n    return estimateTensionFromChapter(chapter);\r\n  }\r\n}\r\n\r\nexport const tensionController = new TensionController();\r\n"]}

package/dist/agents/writer.d.ts

@@ -0,0 +1,12 @@
+import type { GenerationContext, WriterOutput } from '../types/index.js';
+import type { CanonStore } from '../memory/canonStore.js';
+import type { MemoryRetriever } from '../memory/memoryRetriever.js';
+export declare class ChapterWriter {
+    private promptTemplate;
+    constructor();
+    write(context: GenerationContext, canon?: CanonStore, memoryRetriever?: MemoryRetriever): Promise<WriterOutput>;
+    continue(existingContent: string, context: GenerationContext): Promise<string>;
+    private inferChapterGoal;
+    private extractTitle;
+}
+export declare const writer: ChapterWriter;

package/dist/agents/writer.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writer = exports.ChapterWriter = void 0;
+const client_js_1 = require("../llm/client.js");
+const canonStore_js_1 = require("../memory/canonStore.js");
+const WRITER_PROMPT = `You are a professional novelist writing immersive narrative prose.
+
+Write Chapter {{chapterNumber}} of the novel.
+
+## Story Bible
+
+**Title:** {{title}}
+**Theme:** {{theme}}
+**Genre:** {{genre}}
+**Setting:** {{setting}}
+**Tone:** {{tone}}
+
+**Premise:**
+{{premise}}
+
+## Characters
+
+{{characters}}
+
+## Story Canon
+
+{{canon}}
+
+## Relevant Memories
+
+{{memories}}
+
+## Recent Chapter Summaries
+
+{{recentSummaries}}
+
+## Chapter Goal
+
+{{chapterGoal}}
+
+## Writing Guidelines
+
+- Write in third person limited perspective
+- Show, don't tell
+- Maintain consistent character voices
+- Build toward the chapter goal naturally
+- End at a natural stopping point (not mid-scene)
+- Reference relevant past memories naturally when appropriate
+- Target length: {{targetWordCount}} words
+
+Write the full chapter now.`;
+class ChapterWriter {
+    promptTemplate;
+    constructor() {
+        this.promptTemplate = WRITER_PROMPT;
+    }
+    async write(context, canon, memoryRetriever) {
+        const { bible, state, chapterNumber, targetWordCount = 2000 } = context;
+        const canonSection = canon ? (0, canonStore_js_1.formatCanonForPrompt)(canon) : '';
+        // Retrieve relevant memories
+        let memoriesSection = 'No relevant memories yet.';
+        if (memoryRetriever && chapterNumber > 1) {
+            const memories = await memoryRetriever.retrieveForChapter({
+                bible,
+                state,
+                currentChapter: chapterNumber,
+            });
+            memoriesSection = memoryRetriever.formatMemoriesForPrompt(memories) || 'No highly relevant memories for this chapter.';
+        }
+        const recentSummaries = state.chapterSummaries
+            .slice(-3)
+            .map(s => `Chapter ${s.chapterNumber}: ${s.summary}`)
+            .join('\n\n') || 'This is the first chapter.';
+        const characters = bible.characters
+            .map(c => `- ${c.name} (${c.role}): ${c.personality.join(', ')}. Goals: ${c.goals.join(', ')}`)
+            .join('\n');
+        const chapterGoal = this.inferChapterGoal(bible, state, chapterNumber);
+        const prompt = this.promptTemplate
+            .replace('{{chapterNumber}}', chapterNumber.toString())
+            .replace('{{title}}', bible.title)
+            .replace('{{theme}}', bible.theme)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{setting}}', bible.setting)
+            .replace('{{tone}}', bible.tone)
+            .replace('{{premise}}', bible.premise)
+            .replace('{{characters}}', characters)
+            .replace('{{memories}}', memoriesSection)
+            .replace('{{recentSummaries}}', recentSummaries)
+            .replace('{{chapterGoal}}', chapterGoal)
+            .replace('{{targetWordCount}}', targetWordCount.toString())
+            .replace('{{canon}}', canonSection);
+        const content = await (0, client_js_1.getLLM)().complete(prompt, {
+            temperature: 0.8,
+            maxTokens: 4000,
+        });
+        const title = this.extractTitle(content) || `Chapter ${chapterNumber}`;
+        const wordCount = content.split(/\s+/).length;
+        return { content, title, wordCount };
+    }
+    async continue(existingContent, context) {
+        const prompt = `Continue the following chapter from where it left off. Do not repeat what has already been written. Write the continuation only.
+
+## Story Context
+
+${context.bible.premise}
+
+## Existing Chapter Content
+
+${existingContent}
+
+## Continuation
+
+Continue naturally from the last sentence:`;
+        const continuation = await (0, client_js_1.getLLM)().complete(prompt, {
+            temperature: 0.8,
+            maxTokens: 2000,
+        });
+        return existingContent + '\n\n' + continuation;
+    }
+    inferChapterGoal(bible, state, chapterNumber) {
+        const progress = chapterNumber / bible.targetChapters;
+        if (progress < 0.2) {
+            return 'Establish the setting, introduce the main character, and hint at the central conflict.';
+        }
+        else if (progress < 0.5) {
+            return 'Develop the conflict, introduce complications, and raise stakes.';
+        }
+        else if (progress < 0.8) {
+            return 'Escalate tension, reveal important information, and move toward climax.';
+        }
+        else {
+            return 'Build toward resolution and begin tying up plot threads.';
+        }
+    }
+    extractTitle(content) {
+        const lines = content.split('\n');
+        for (const line of lines.slice(0, 10)) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('# ') || trimmed.startsWith('Chapter')) {
+                return trimmed.replace(/^#\s*/, '').trim();
+            }
+        }
+        return null;
+    }
+}
+exports.ChapterWriter = ChapterWriter;
+exports.writer = new ChapterWriter();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../../src/agents/writer.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { GenerationContext, WriterOutput } from '../types/index.js';\r\nimport type { CanonStore } from '../memory/canonStore.js';\r\nimport { formatCanonForPrompt } from '../memory/canonStore.js';\r\nimport type { MemoryRetriever } from '../memory/memoryRetriever.js';\r\n\r\nconst WRITER_PROMPT = `You are a professional novelist writing immersive narrative prose.\r\n\r\nWrite Chapter {{chapterNumber}} of the novel.\r\n\r\n## Story Bible\r\n\r\n**Title:** {{title}}\r\n**Theme:** {{theme}}\r\n**Genre:** {{genre}}\r\n**Setting:** {{setting}}\r\n**Tone:** {{tone}}\r\n\r\n**Premise:**\r\n{{premise}}\r\n\r\n## Characters\r\n\r\n{{characters}}\r\n\r\n## Story Canon\r\n\r\n{{canon}}\r\n\r\n## Relevant Memories\r\n\r\n{{memories}}\r\n\r\n## Recent Chapter Summaries\r\n\r\n{{recentSummaries}}\r\n\r\n## Chapter Goal\r\n\r\n{{chapterGoal}}\r\n\r\n## Writing Guidelines\r\n\r\n- Write in third person limited perspective\r\n- Show, don't tell\r\n- Maintain consistent character voices\r\n- Build toward the chapter goal naturally\r\n- End at a natural stopping point (not mid-scene)\r\n- Reference relevant past memories naturally when appropriate\r\n- Target length: {{targetWordCount}} words\r\n\r\nWrite the full chapter now.`;\r\n\r\nexport class ChapterWriter {\r\n  private promptTemplate: string;\r\n\r\n  constructor() {\r\n    this.promptTemplate = WRITER_PROMPT;\r\n  }\r\n\r\n  async write(context: GenerationContext, canon?: CanonStore, memoryRetriever?: MemoryRetriever): Promise<WriterOutput> {\r\n    const { bible, state, chapterNumber, targetWordCount = 2000 } = context;\r\n    \r\n    const canonSection = canon ? formatCanonForPrompt(canon) : '';\r\n\r\n    // Retrieve relevant memories\r\n    let memoriesSection = 'No relevant memories yet.';\r\n    if (memoryRetriever && chapterNumber > 1) {\r\n      const memories = await memoryRetriever.retrieveForChapter({\r\n        bible,\r\n        state,\r\n        currentChapter: chapterNumber,\r\n      });\r\n      memoriesSection = memoryRetriever.formatMemoriesForPrompt(memories) || 'No highly relevant memories for this chapter.';\r\n    }\r\n\r\n    const recentSummaries = state.chapterSummaries\r\n      .slice(-3)\r\n      .map(s => `Chapter ${s.chapterNumber}: ${s.summary}`)\r\n      .join('\\n\\n') || 'This is the first chapter.';\r\n\r\n    const characters = bible.characters\r\n      .map(c => `- ${c.name} (${c.role}): ${c.personality.join(', ')}. Goals: ${c.goals.join(', ')}`)\r\n      .join('\\n');\r\n\r\n    const chapterGoal = this.inferChapterGoal(bible, state, chapterNumber);\r\n\r\n    const prompt = this.promptTemplate\r\n      .replace('{{chapterNumber}}', chapterNumber.toString())\r\n      .replace('{{title}}', bible.title)\r\n      .replace('{{theme}}', bible.theme)\r\n      .replace('{{genre}}', bible.genre)\r\n      .replace('{{setting}}', bible.setting)\r\n      .replace('{{tone}}', bible.tone)\r\n      .replace('{{premise}}', bible.premise)\r\n      .replace('{{characters}}', characters)\r\n      .replace('{{memories}}', memoriesSection)\r\n      .replace('{{recentSummaries}}', recentSummaries)\r\n      .replace('{{chapterGoal}}', chapterGoal)\r\n      .replace('{{targetWordCount}}', targetWordCount.toString())\r\n      .replace('{{canon}}', canonSection);\r\n\r\n    const content = await getLLM().complete(prompt, {\r\n      temperature: 0.8,\r\n      maxTokens: 4000,\r\n    });\r\n\r\n    const title = this.extractTitle(content) || `Chapter ${chapterNumber}`;\r\n    const wordCount = content.split(/\\s+/).length;\r\n\r\n    return { content, title, wordCount };\r\n  }\r\n\r\n  async continue(existingContent: string, context: GenerationContext): Promise<string> {\r\n    const prompt = `Continue the following chapter from where it left off. Do not repeat what has already been written. Write the continuation only.\r\n\r\n## Story Context\r\n\r\n${context.bible.premise}\r\n\r\n## Existing Chapter Content\r\n\r\n${existingContent}\r\n\r\n## Continuation\r\n\r\nContinue naturally from the last sentence:`;\r\n\r\n    const continuation = await getLLM().complete(prompt, {\r\n      temperature: 0.8,\r\n      maxTokens: 2000,\r\n    });\r\n\r\n    return existingContent + '\\n\\n' + continuation;\r\n  }\r\n\r\n  private inferChapterGoal(bible: GenerationContext['bible'], state: GenerationContext['state'], chapterNumber: number): string {\r\n    const progress = chapterNumber / bible.targetChapters;\r\n    \r\n    if (progress < 0.2) {\r\n      return 'Establish the setting, introduce the main character, and hint at the central conflict.';\r\n    } else if (progress < 0.5) {\r\n      return 'Develop the conflict, introduce complications, and raise stakes.';\r\n    } else if (progress < 0.8) {\r\n      return 'Escalate tension, reveal important information, and move toward climax.';\r\n    } else {\r\n      return 'Build toward resolution and begin tying up plot threads.';\r\n    }\r\n  }\r\n\r\n  private extractTitle(content: string): string | null {\r\n    const lines = content.split('\\n');\r\n    for (const line of lines.slice(0, 10)) {\r\n      const trimmed = line.trim();\r\n      if (trimmed.startsWith('# ') || trimmed.startsWith('Chapter')) {\r\n        return trimmed.replace(/^#\\s*/, '').trim();\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n}\r\n\r\nexport const writer = new ChapterWriter();\r\n"]}

package/dist/constraints/constraintGraph.d.ts

@@ -0,0 +1,117 @@
+import type { CharacterState } from '../story/structuredState.js';
+export type NodeType = 'character' | 'location' | 'fact' | 'event' | 'item';
+export interface ConstraintNode {
+    id: string;
+    type: NodeType;
+    label: string;
+    properties: Record<string, any>;
+    chapterEstablished?: number;
+}
+export interface ConstraintEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: string;
+    properties: Record<string, any>;
+}
+export interface ConstraintViolation {
+    type: 'canon' | 'location' | 'knowledge' | 'timeline' | 'logic';
+    severity: 'error' | 'warning';
+    description: string;
+    nodes: string[];
+    suggestedFix?: string;
+}
+export declare class ConstraintGraph {
+    private nodes;
+    private edges;
+    private adjacencyList;
+    /**
+     * Add a node to the graph
+     */
+    addNode(node: ConstraintNode): void;
+    /**
+     * Add an edge between nodes
+     */
+    addEdge(edge: ConstraintEdge): void;
+    /**
+     * Get a node by ID
+     */
+    getNode(id: string): ConstraintNode | undefined;
+    /**
+     * Get all edges from a node
+     */
+    getEdgesFrom(nodeId: string): ConstraintEdge[];
+    /**
+     * Get all edges to a node
+     */
+    getEdgesTo(nodeId: string): ConstraintEdge[];
+    /**
+     * Get neighbors of a node
+     */
+    getNeighbors(nodeId: string): ConstraintNode[];
+    /**
+     * Add character to graph
+     */
+    addCharacter(character: CharacterState, chapter: number): void;
+    /**
+     * Add location to graph
+     */
+    addLocation(name: string, description: string, chapter: number): void;
+    /**
+     * Add event to graph
+     */
+    addEvent(id: string, description: string, participants: string[], chapter: number): void;
+    /**
+     * Update character location
+     */
+    updateCharacterLocation(characterName: string, newLocation: string, chapter: number): void;
+    /**
+     * Check for constraint violations
+     */
+    checkConstraints(currentChapter: number): ConstraintViolation[];
+    /**
+     * Check location consistency (no teleporting)
+     */
+    private checkLocationConsistency;
+    /**
+     * Check knowledge consistency (no impossible knowledge)
+     */
+    private checkKnowledgeConsistency;
+    /**
+     * Check timeline consistency
+     */
+    private checkTimelineConsistency;
+    /**
+     * Check logical consistency
+     */
+    private checkLogicalConsistency;
+    /**
+     * Query what a character knows
+     */
+    getCharacterKnowledge(characterName: string): ConstraintNode[];
+    /**
+     * Query where a character is
+     */
+    getCharacterLocation(characterName: string): string | undefined;
+    /**
+     * Serialize graph
+     */
+    serialize(): string;
+    /**
+     * Load graph from serialized data
+     */
+    load(data: string): void;
+    /**
+     * Get graph statistics
+     */
+    getStats(): {
+        nodes: number;
+        edges: number;
+        byType: Record<NodeType, number>;
+    };
+    /**
+     * Sanitize string for use as ID
+     */
+    private sanitizeId;
+}
+export declare function createConstraintGraph(): ConstraintGraph;