@narrative-os/engine 0.1.0

package/dist/memory/stateUpdater.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateUpdaterPipeline = exports.StateUpdaterPipeline = void 0;
+const client_js_1 = require("../llm/client.js");
+const STATE_EXTRACTION_PROMPT = `You are a narrative state extractor. Analyze this chapter and extract all state changes.
+
+## Story Bible
+
+**Title:** {{title}}
+**Genre:** {{genre}}
+
+## Chapter {{chapterNumber}}: {{chapterTitle}}
+
+{{chapterContent}}
+
+## Current Character States
+
+{{characters}}
+
+## Current Plot Threads
+
+{{plotThreads}}
+
+## Extraction Task
+
+Extract the following:
+
+1. **Character Changes**: How do characters change? (emotion, location, knowledge, relationships, goals)
+2. **Plot Thread Changes**: How do plot threads progress? (status, tension, summary updates)
+3. **New Facts**: Any new canon facts established?
+4. **World Changes**: Any changes to the world setting?
+
+Output JSON:
+{
+  "characterChanges": [
+    {
+      "name": "character name",
+      "emotionalState": "new emotional state or null",
+      "location": "new location or null",
+      "newKnowledge": ["facts learned"],
+      "relationshipChanges": [{"with": "other character", "newStatus": "relationship"}],
+      "newGoal": "new goal or null"
+    }
+  ],
+  "plotThreadChanges": [
+    {
+      "id": "thread id",
+      "status": "new status or null",
+      "tensionDelta": 0.1,
+      "newSummary": "updated summary or null"
+    }
+  ],
+  "newFacts": [
+    {
+      "category": "character|world|plot",
+      "subject": "subject",
+      "attribute": "attribute",
+      "value": "value"
+    }
+  ],
+  "worldChanges": ["any changes to the world"]
+}`;
+class StateUpdaterPipeline {
+    /**
+     * Run the complete post-chapter update pipeline
+     */
+    async update(context) {
+        const { chapter, bible, currentState, canon, vectorStore, constraintGraph } = context;
+        const changes = [];
+        let memoriesAdded = 0;
+        let canonFactsAdded = 0;
+        // Step 1: Extract state changes using LLM
+        const extraction = await this.extractChanges(chapter, bible, currentState);
+        // Step 2: Update structured state
+        let newState = { ...currentState };
+        newState.chapter = chapter.number;
+        // Apply character changes
+        for (const change of extraction.characterChanges) {
+            if (newState.characters[change.name]) {
+                const char = newState.characters[change.name];
+                if (change.emotionalState) {
+                    char.emotionalState = change.emotionalState;
+                    changes.push({
+                        type: 'character',
+                        description: `${change.name} emotional state → ${change.emotionalState}`,
+                        chapter: chapter.number,
+                    });
+                }
+                if (change.location) {
+                    const oldLocation = char.location;
+                    char.location = change.location;
+                    changes.push({
+                        type: 'character',
+                        description: `${change.name} moved: ${oldLocation} → ${change.location}`,
+                        chapter: chapter.number,
+                    });
+                    // Update constraint graph
+                    constraintGraph.updateCharacterLocation(change.name, change.location, chapter.number);
+                }
+                if (change.newKnowledge) {
+                    char.knowledge = [...char.knowledge, ...change.newKnowledge];
+                    // Add to constraint graph
+                    for (const knowledge of change.newKnowledge) {
+                        const factId = `fact-${this.sanitizeId(knowledge)}`;
+                        if (!constraintGraph.getNode(factId)) {
+                            constraintGraph.addNode({
+                                id: factId,
+                                type: 'fact',
+                                label: knowledge,
+                                properties: {},
+                                chapterEstablished: chapter.number,
+                            });
+                        }
+                        constraintGraph.addEdge({
+                            id: `edge-${change.name}-knows-${factId}`,
+                            from: `char-${change.name}`,
+                            to: factId,
+                            type: 'knows',
+                            properties: { since: chapter.number },
+                        });
+                    }
+                }
+                if (change.relationshipChanges) {
+                    for (const rel of change.relationshipChanges) {
+                        char.relationships[rel.with] = rel.newStatus;
+                    }
+                }
+                if (change.newGoal) {
+                    char.goals = [...char.goals, change.newGoal];
+                }
+            }
+        }
+        // Apply plot thread changes
+        for (const change of extraction.plotThreadChanges) {
+            if (newState.plotThreads[change.id]) {
+                const thread = newState.plotThreads[change.id];
+                if (change.status) {
+                    thread.status = change.status;
+                }
+                if (change.tensionDelta) {
+                    thread.tension = Math.max(0, Math.min(1, thread.tension + change.tensionDelta));
+                }
+                if (change.newSummary) {
+                    thread.summary = change.newSummary;
+                }
+                thread.lastChapter = chapter.number;
+                changes.push({
+                    type: 'plot',
+                    description: `${thread.name} updated: ${change.status || 'progress'}`,
+                    chapter: chapter.number,
+                });
+            }
+        }
+        // Step 3: Add new canon facts
+        for (const fact of extraction.newFacts) {
+            // In real implementation, would add to canon store
+            canonFactsAdded++;
+            changes.push({
+                type: 'canon',
+                description: `Canon: ${fact.subject} ${fact.attribute} = ${fact.value}`,
+                chapter: chapter.number,
+            });
+        }
+        // Step 4: Extract and add narrative memories
+        const memories = await this.extractMemories(chapter, bible);
+        for (const memory of memories) {
+            await vectorStore.addMemory({
+                storyId: chapter.storyId,
+                chapterNumber: chapter.number,
+                content: memory.content,
+                category: memory.category,
+                timestamp: new Date(),
+            });
+            memoriesAdded++;
+        }
+        changes.push({
+            type: 'memory',
+            description: `${memoriesAdded} narrative memories extracted`,
+            chapter: chapter.number,
+        });
+        // Step 5: Add event to constraint graph
+        constraintGraph.addEvent(`ch${chapter.number}`, chapter.summary, Object.keys(newState.characters), chapter.number);
+        // Step 6: Update recent events
+        newState.recentEvents = [...newState.recentEvents, chapter.summary].slice(-10);
+        return {
+            structuredState: newState,
+            memoriesAdded,
+            canonFactsAdded,
+            graphUpdated: true,
+            changes,
+        };
+    }
+    /**
+     * Extract state changes from chapter
+     */
+    async extractChanges(chapter, bible, state) {
+        const characters = Object.values(state.characters)
+            .map(c => `- ${c.name}: ${c.emotionalState}, at ${c.location}`)
+            .join('\n');
+        const plotThreads = Object.values(state.plotThreads)
+            .map(t => `- ${t.name} (${t.status}, ${Math.round(t.tension * 100)}% tension)`)
+            .join('\n');
+        const prompt = STATE_EXTRACTION_PROMPT
+            .replace('{{title}}', bible.title)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{chapterNumber}}', chapter.number.toString())
+            .replace('{{chapterTitle}}', chapter.title)
+            .replace('{{chapterContent}}', chapter.content.substring(0, 5000))
+            .replace('{{characters}}', characters)
+            .replace('{{plotThreads}}', plotThreads);
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.3,
+            maxTokens: 2000,
+        });
+        return result;
+    }
+    /**
+     * Extract narrative memories from chapter
+     */
+    async extractMemories(chapter, bible) {
+        // Simplified memory extraction
+        // In real implementation, would use MemoryExtractor agent
+        const memories = [];
+        // Extract key events from summary
+        if (chapter.summary) {
+            memories.push({
+                content: chapter.summary,
+                category: 'event',
+            });
+        }
+        // Add chapter title as memory
+        memories.push({
+            content: `Chapter ${chapter.number}: ${chapter.title}`,
+            category: 'plot',
+        });
+        return memories;
+    }
+    /**
+     * Quick update without LLM (for testing)
+     */
+    async quickUpdate(context) {
+        const { chapter, currentState, vectorStore, constraintGraph } = context;
+        const changes = [];
+        let newState = { ...currentState };
+        newState.chapter = chapter.number;
+        // Add basic memories
+        await vectorStore.addMemory({
+            storyId: chapter.storyId,
+            chapterNumber: chapter.number,
+            content: chapter.summary,
+            category: 'event',
+            timestamp: new Date(),
+        });
+        await vectorStore.addMemory({
+            storyId: chapter.storyId,
+            chapterNumber: chapter.number,
+            content: `Chapter ${chapter.number}: ${chapter.title}`,
+            category: 'plot',
+            timestamp: new Date(),
+        });
+        changes.push({
+            type: 'memory',
+            description: `2 memories added (quick mode)`,
+            chapter: chapter.number,
+        });
+        // Update recent events
+        newState.recentEvents = [...newState.recentEvents, chapter.summary].slice(-10);
+        // Add to constraint graph
+        constraintGraph.addEvent(`ch${chapter.number}`, chapter.summary, Object.keys(newState.characters), chapter.number);
+        return {
+            structuredState: newState,
+            memoriesAdded: 2,
+            canonFactsAdded: 0,
+            graphUpdated: true,
+            changes,
+        };
+    }
+    /**
+     * Format update result
+     */
+    formatResult(result) {
+        const lines = ['## State Update Result'];
+        lines.push(`\n**Memories Added:** ${result.memoriesAdded}`);
+        lines.push(`**Canon Facts Added:** ${result.canonFactsAdded}`);
+        lines.push(`**Graph Updated:** ${result.graphUpdated ? '✅' : '❌'}`);
+        if (result.changes.length > 0) {
+            lines.push('\n**Changes:**');
+            const byType = {
+                character: [],
+                plot: [],
+                world: [],
+                canon: [],
+                memory: [],
+            };
+            for (const change of result.changes) {
+                byType[change.type].push(change);
+            }
+            for (const [type, changes] of Object.entries(byType)) {
+                if (changes.length > 0) {
+                    lines.push(`\n*${type.charAt(0).toUpperCase() + type.slice(1)}:*`);
+                    for (const change of changes) {
+                        lines.push(`  - ${change.description}`);
+                    }
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    sanitizeId(str) {
+        return str.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 50);
+    }
+}
+exports.StateUpdaterPipeline = StateUpdaterPipeline;
+exports.stateUpdaterPipeline = new StateUpdaterPipeline();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateUpdater.js","sourceRoot":"","sources":["../../src/memory/stateUpdater.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { Chapter, StoryBible } from '../types/index.js';\r\nimport type { StoryStructuredState, CharacterState, PlotThreadState } from '../story/structuredState.js';\r\nimport type { VectorStore, NarrativeMemory } from './vectorStore.js';\r\nimport type { CanonStore } from './canonStore.js';\r\nimport { ConstraintGraph } from '../constraints/constraintGraph.js';\r\n\r\nexport interface StateUpdateResult {\r\n  structuredState: StoryStructuredState;\r\n  memoriesAdded: number;\r\n  canonFactsAdded: number;\r\n  graphUpdated: boolean;\r\n  changes: StateChange[];\r\n}\r\n\r\nexport interface StateChange {\r\n  type: 'character' | 'plot' | 'world' | 'canon' | 'memory';\r\n  description: string;\r\n  chapter: number;\r\n}\r\n\r\nexport interface UpdateContext {\r\n  chapter: Chapter;\r\n  bible: StoryBible;\r\n  currentState: StoryStructuredState;\r\n  canon: CanonStore;\r\n  vectorStore: VectorStore;\r\n  constraintGraph: ConstraintGraph;\r\n}\r\n\r\nconst STATE_EXTRACTION_PROMPT = `You are a narrative state extractor. Analyze this chapter and extract all state changes.\r\n\r\n## Story Bible\r\n\r\n**Title:** {{title}}\r\n**Genre:** {{genre}}\r\n\r\n## Chapter {{chapterNumber}}: {{chapterTitle}}\r\n\r\n{{chapterContent}}\r\n\r\n## Current Character States\r\n\r\n{{characters}}\r\n\r\n## Current Plot Threads\r\n\r\n{{plotThreads}}\r\n\r\n## Extraction Task\r\n\r\nExtract the following:\r\n\r\n1. **Character Changes**: How do characters change? (emotion, location, knowledge, relationships, goals)\r\n2. **Plot Thread Changes**: How do plot threads progress? (status, tension, summary updates)\r\n3. **New Facts**: Any new canon facts established?\r\n4. **World Changes**: Any changes to the world setting?\r\n\r\nOutput JSON:\r\n{\r\n  \"characterChanges\": [\r\n    {\r\n      \"name\": \"character name\",\r\n      \"emotionalState\": \"new emotional state or null\",\r\n      \"location\": \"new location or null\",\r\n      \"newKnowledge\": [\"facts learned\"],\r\n      \"relationshipChanges\": [{\"with\": \"other character\", \"newStatus\": \"relationship\"}],\r\n      \"newGoal\": \"new goal or null\"\r\n    }\r\n  ],\r\n  \"plotThreadChanges\": [\r\n    {\r\n      \"id\": \"thread id\",\r\n      \"status\": \"new status or null\",\r\n      \"tensionDelta\": 0.1,\r\n      \"newSummary\": \"updated summary or null\"\r\n    }\r\n  ],\r\n  \"newFacts\": [\r\n    {\r\n      \"category\": \"character|world|plot\",\r\n      \"subject\": \"subject\",\r\n      \"attribute\": \"attribute\",\r\n      \"value\": \"value\"\r\n    }\r\n  ],\r\n  \"worldChanges\": [\"any changes to the world\"]\r\n}`;\r\n\r\nexport class StateUpdaterPipeline {\r\n  /**\r\n   * Run the complete post-chapter update pipeline\r\n   */\r\n  async update(context: UpdateContext): Promise<StateUpdateResult> {\r\n    const { chapter, bible, currentState, canon, vectorStore, constraintGraph } = context;\r\n    \r\n    const changes: StateChange[] = [];\r\n    let memoriesAdded = 0;\r\n    let canonFactsAdded = 0;\r\n    \r\n    // Step 1: Extract state changes using LLM\r\n    const extraction = await this.extractChanges(chapter, bible, currentState);\r\n    \r\n    // Step 2: Update structured state\r\n    let newState = { ...currentState };\r\n    newState.chapter = chapter.number;\r\n    \r\n    // Apply character changes\r\n    for (const change of extraction.characterChanges) {\r\n      if (newState.characters[change.name]) {\r\n        const char = newState.characters[change.name];\r\n        \r\n        if (change.emotionalState) {\r\n          char.emotionalState = change.emotionalState;\r\n          changes.push({\r\n            type: 'character',\r\n            description: `${change.name} emotional state → ${change.emotionalState}`,\r\n            chapter: chapter.number,\r\n          });\r\n        }\r\n        \r\n        if (change.location) {\r\n          const oldLocation = char.location;\r\n          char.location = change.location;\r\n          changes.push({\r\n            type: 'character',\r\n            description: `${change.name} moved: ${oldLocation} → ${change.location}`,\r\n            chapter: chapter.number,\r\n          });\r\n          \r\n          // Update constraint graph\r\n          constraintGraph.updateCharacterLocation(change.name, change.location, chapter.number);\r\n        }\r\n        \r\n        if (change.newKnowledge) {\r\n          char.knowledge = [...char.knowledge, ...change.newKnowledge];\r\n          \r\n          // Add to constraint graph\r\n          for (const knowledge of change.newKnowledge) {\r\n            const factId = `fact-${this.sanitizeId(knowledge)}`;\r\n            if (!constraintGraph.getNode(factId)) {\r\n              constraintGraph.addNode({\r\n                id: factId,\r\n                type: 'fact',\r\n                label: knowledge,\r\n                properties: {},\r\n                chapterEstablished: chapter.number,\r\n              });\r\n            }\r\n            \r\n            constraintGraph.addEdge({\r\n              id: `edge-${change.name}-knows-${factId}`,\r\n              from: `char-${change.name}`,\r\n              to: factId,\r\n              type: 'knows',\r\n              properties: { since: chapter.number },\r\n            });\r\n          }\r\n        }\r\n        \r\n        if (change.relationshipChanges) {\r\n          for (const rel of change.relationshipChanges) {\r\n            char.relationships[rel.with] = rel.newStatus;\r\n          }\r\n        }\r\n        \r\n        if (change.newGoal) {\r\n          char.goals = [...char.goals, change.newGoal];\r\n        }\r\n      }\r\n    }\r\n    \r\n    // Apply plot thread changes\r\n    for (const change of extraction.plotThreadChanges) {\r\n      if (newState.plotThreads[change.id]) {\r\n        const thread = newState.plotThreads[change.id];\r\n        \r\n        if (change.status) {\r\n          thread.status = change.status;\r\n        }\r\n        \r\n        if (change.tensionDelta) {\r\n          thread.tension = Math.max(0, Math.min(1, thread.tension + change.tensionDelta));\r\n        }\r\n        \r\n        if (change.newSummary) {\r\n          thread.summary = change.newSummary;\r\n        }\r\n        \r\n        thread.lastChapter = chapter.number;\r\n        \r\n        changes.push({\r\n          type: 'plot',\r\n          description: `${thread.name} updated: ${change.status || 'progress'}`,\r\n          chapter: chapter.number,\r\n        });\r\n      }\r\n    }\r\n    \r\n    // Step 3: Add new canon facts\r\n    for (const fact of extraction.newFacts) {\r\n      // In real implementation, would add to canon store\r\n      canonFactsAdded++;\r\n      changes.push({\r\n        type: 'canon',\r\n        description: `Canon: ${fact.subject} ${fact.attribute} = ${fact.value}`,\r\n        chapter: chapter.number,\r\n      });\r\n    }\r\n    \r\n    // Step 4: Extract and add narrative memories\r\n    const memories = await this.extractMemories(chapter, bible);\r\n    for (const memory of memories) {\r\n      await vectorStore.addMemory({\r\n        storyId: chapter.storyId,\r\n        chapterNumber: chapter.number,\r\n        content: memory.content,\r\n        category: memory.category,\r\n        timestamp: new Date(),\r\n      });\r\n      memoriesAdded++;\r\n    }\r\n    \r\n    changes.push({\r\n      type: 'memory',\r\n      description: `${memoriesAdded} narrative memories extracted`,\r\n      chapter: chapter.number,\r\n    });\r\n    \r\n    // Step 5: Add event to constraint graph\r\n    constraintGraph.addEvent(\r\n      `ch${chapter.number}`,\r\n      chapter.summary,\r\n      Object.keys(newState.characters),\r\n      chapter.number\r\n    );\r\n    \r\n    // Step 6: Update recent events\r\n    newState.recentEvents = [...newState.recentEvents, chapter.summary].slice(-10);\r\n    \r\n    return {\r\n      structuredState: newState,\r\n      memoriesAdded,\r\n      canonFactsAdded,\r\n      graphUpdated: true,\r\n      changes,\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Extract state changes from chapter\r\n   */\r\n  private async extractChanges(\r\n    chapter: Chapter,\r\n    bible: StoryBible,\r\n    state: StoryStructuredState\r\n  ): Promise<{\r\n    characterChanges: Array<{\r\n      name: string;\r\n      emotionalState?: string;\r\n      location?: string;\r\n      newKnowledge?: string[];\r\n      relationshipChanges?: Array<{ with: string; newStatus: string }>;\r\n      newGoal?: string;\r\n    }>;\r\n    plotThreadChanges: Array<{\r\n      id: string;\r\n      status?: 'dormant' | 'active' | 'escalating' | 'resolved';\r\n      tensionDelta?: number;\r\n      newSummary?: string;\r\n    }>;\r\n    newFacts: Array<{\r\n      category: 'character' | 'world' | 'plot';\r\n      subject: string;\r\n      attribute: string;\r\n      value: string;\r\n    }>;\r\n    worldChanges: string[];\r\n  }> {\r\n    const characters = Object.values(state.characters)\r\n      .map(c => `- ${c.name}: ${c.emotionalState}, at ${c.location}`)\r\n      .join('\\n');\r\n    \r\n    const plotThreads = Object.values(state.plotThreads)\r\n      .map(t => `- ${t.name} (${t.status}, ${Math.round(t.tension * 100)}% tension)`)\r\n      .join('\\n');\r\n    \r\n    const prompt = STATE_EXTRACTION_PROMPT\r\n      .replace('{{title}}', bible.title)\r\n      .replace('{{genre}}', bible.genre)\r\n      .replace('{{chapterNumber}}', chapter.number.toString())\r\n      .replace('{{chapterTitle}}', chapter.title)\r\n      .replace('{{chapterContent}}', chapter.content.substring(0, 5000))\r\n      .replace('{{characters}}', characters)\r\n      .replace('{{plotThreads}}', plotThreads);\r\n    \r\n    const result = await getLLM().completeJSON<{\r\n      characterChanges: any[];\r\n      plotThreadChanges: any[];\r\n      newFacts: any[];\r\n      worldChanges: string[];\r\n    }>(prompt, {\r\n      temperature: 0.3,\r\n      maxTokens: 2000,\r\n    });\r\n    \r\n    return result;\r\n  }\r\n  \r\n  /**\r\n   * Extract narrative memories from chapter\r\n   */\r\n  private async extractMemories(\r\n    chapter: Chapter,\r\n    bible: StoryBible\r\n  ): Promise<Array<{ content: string; category: NarrativeMemory['category'] }>> {\r\n    // Simplified memory extraction\r\n    // In real implementation, would use MemoryExtractor agent\r\n    const memories: Array<{ content: string; category: NarrativeMemory['category'] }> = [];\r\n    \r\n    // Extract key events from summary\r\n    if (chapter.summary) {\r\n      memories.push({\r\n        content: chapter.summary,\r\n        category: 'event',\r\n      });\r\n    }\r\n    \r\n    // Add chapter title as memory\r\n    memories.push({\r\n      content: `Chapter ${chapter.number}: ${chapter.title}`,\r\n      category: 'plot',\r\n    });\r\n    \r\n    return memories;\r\n  }\r\n  \r\n  /**\r\n   * Quick update without LLM (for testing)\r\n   */\r\n  async quickUpdate(context: UpdateContext): Promise<StateUpdateResult> {\r\n    const { chapter, currentState, vectorStore, constraintGraph } = context;\r\n    \r\n    const changes: StateChange[] = [];\r\n    let newState = { ...currentState };\r\n    newState.chapter = chapter.number;\r\n    \r\n    // Add basic memories\r\n    await vectorStore.addMemory({\r\n      storyId: chapter.storyId,\r\n      chapterNumber: chapter.number,\r\n      content: chapter.summary,\r\n      category: 'event',\r\n      timestamp: new Date(),\r\n    });\r\n    \r\n    await vectorStore.addMemory({\r\n      storyId: chapter.storyId,\r\n      chapterNumber: chapter.number,\r\n      content: `Chapter ${chapter.number}: ${chapter.title}`,\r\n      category: 'plot',\r\n      timestamp: new Date(),\r\n    });\r\n    \r\n    changes.push({\r\n      type: 'memory',\r\n      description: `2 memories added (quick mode)`,\r\n      chapter: chapter.number,\r\n    });\r\n    \r\n    // Update recent events\r\n    newState.recentEvents = [...newState.recentEvents, chapter.summary].slice(-10);\r\n    \r\n    // Add to constraint graph\r\n    constraintGraph.addEvent(\r\n      `ch${chapter.number}`,\r\n      chapter.summary,\r\n      Object.keys(newState.characters),\r\n      chapter.number\r\n    );\r\n    \r\n    return {\r\n      structuredState: newState,\r\n      memoriesAdded: 2,\r\n      canonFactsAdded: 0,\r\n      graphUpdated: true,\r\n      changes,\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Format update result\r\n   */\r\n  formatResult(result: StateUpdateResult): string {\r\n    const lines: string[] = ['## State Update Result'];\r\n    \r\n    lines.push(`\\n**Memories Added:** ${result.memoriesAdded}`);\r\n    lines.push(`**Canon Facts Added:** ${result.canonFactsAdded}`);\r\n    lines.push(`**Graph Updated:** ${result.graphUpdated ? '✅' : '❌'}`);\r\n    \r\n    if (result.changes.length > 0) {\r\n      lines.push('\\n**Changes:**');\r\n      \r\n      const byType: Record<string, StateChange[]> = {\r\n        character: [],\r\n        plot: [],\r\n        world: [],\r\n        canon: [],\r\n        memory: [],\r\n      };\r\n      \r\n      for (const change of result.changes) {\r\n        byType[change.type].push(change);\r\n      }\r\n      \r\n      for (const [type, changes] of Object.entries(byType)) {\r\n        if (changes.length > 0) {\r\n          lines.push(`\\n*${type.charAt(0).toUpperCase() + type.slice(1)}:*`);\r\n          for (const change of changes) {\r\n            lines.push(`  - ${change.description}`);\r\n          }\r\n        }\r\n      }\r\n    }\r\n    \r\n    return lines.join('\\n');\r\n  }\r\n  \r\n  private sanitizeId(str: string): string {\r\n    return str.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 50);\r\n  }\r\n}\r\n\r\nexport const stateUpdaterPipeline = new StateUpdaterPipeline();\r\n"]}

package/dist/memory/vectorStore.d.ts

@@ -0,0 +1,41 @@
+export interface NarrativeMemory {
+    id: number;
+    storyId: string;
+    chapterNumber: number;
+    content: string;
+    category: 'event' | 'character' | 'world' | 'plot';
+    timestamp: Date;
+    embedding?: number[];
+}
+export interface MemorySearchResult {
+    memory: NarrativeMemory;
+    score: number;
+}
+export declare class VectorStore {
+    private index;
+    private memories;
+    private dimension;
+    private storyId;
+    private nextId;
+    constructor(storyId: string);
+    initialize(maxElements?: number): Promise<void>;
+    /**
+     * Resize the index to accommodate more memories
+     */
+    resizeIndex(newMaxElements: number): void;
+    /**
+     * Ensure capacity for upcoming memories
+     */
+    ensureCapacity(additionalMemories: number): void;
+    addMemory(memory: Omit<NarrativeMemory, 'id' | 'embedding'>): Promise<NarrativeMemory>;
+    searchSimilar(query: string, k?: number): Promise<MemorySearchResult[]>;
+    searchByCategory(query: string, category: NarrativeMemory['category'], k?: number): Promise<MemorySearchResult[]>;
+    getMemoriesByChapter(chapterNumber: number): NarrativeMemory[];
+    getAllMemories(): NarrativeMemory[];
+    private generateEmbedding;
+    private generateMockEmbedding;
+    serialize(): string;
+    load(data: string): Promise<void>;
+}
+export declare function getVectorStore(storyId: string): VectorStore;
+export declare function clearVectorStore(storyId: string): void;

package/dist/memory/vectorStore.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorStore = void 0;
+exports.getVectorStore = getVectorStore;
+exports.clearVectorStore = clearVectorStore;
+const client_js_1 = require("../llm/client.js");
+const hnswlib_node_1 = require("hnswlib-node");
+class VectorStore {
+    index = null;
+    memories = new Map();
+    dimension = 1536; // text-embedding-3-small dimension
+    storyId;
+    nextId = 0;
+    constructor(storyId) {
+        this.storyId = storyId;
+    }
+    async initialize(maxElements = 10000) {
+        this.index = new hnswlib_node_1.HierarchicalNSW('cosine', this.dimension);
+        this.index.initIndex(maxElements, 16, 200);
+        this.nextId = 0;
+        this.memories.clear();
+    }
+    /**
+     * Resize the index to accommodate more memories
+     */
+    resizeIndex(newMaxElements) {
+        if (!this.index) {
+            throw new Error('VectorStore not initialized. Call initialize() first.');
+        }
+        if (newMaxElements <= this.memories.size) {
+            return; // No need to resize
+        }
+        this.index.resizeIndex(newMaxElements);
+    }
+    /**
+     * Ensure capacity for upcoming memories
+     */
+    ensureCapacity(additionalMemories) {
+        const requiredCapacity = this.memories.size + additionalMemories;
+        const currentCapacity = this.index?.getMaxElements() || 0;
+        if (requiredCapacity > currentCapacity) {
+            // Add 50% more capacity or use required, whichever is larger
+            const newCapacity = Math.max(Math.floor(currentCapacity * 1.5), requiredCapacity);
+            this.resizeIndex(newCapacity);
+        }
+    }
+    async addMemory(memory) {
+        if (!this.index) {
+            throw new Error('VectorStore not initialized. Call initialize() first.');
+        }
+        // Auto-resize if we're near capacity (add 50% more)
+        const currentCapacity = this.index.getMaxElements();
+        if (this.memories.size >= currentCapacity - 1) {
+            this.resizeIndex(Math.floor(currentCapacity * 1.5));
+        }
+        const id = this.nextId++;
+        // Generate embedding using OpenAI
+        const embedding = await this.generateEmbedding(memory.content);
+        const fullMemory = {
+            ...memory,
+            id,
+            embedding,
+        };
+        // Add to HNSW index
+        this.index.addPoint(embedding, id);
+        this.memories.set(id, fullMemory);
+        return fullMemory;
+    }
+    async searchSimilar(query, k = 5) {
+        if (!this.index) {
+            throw new Error('VectorStore not initialized. Call initialize() first.');
+        }
+        const queryEmbedding = await this.generateEmbedding(query);
+        const results = this.index.searchKnn(queryEmbedding, k);
+        return results.neighbors.map((id, i) => ({
+            memory: this.memories.get(id),
+            score: results.distances[i],
+        }));
+    }
+    async searchByCategory(query, category, k = 5) {
+        const results = await this.searchSimilar(query, k * 2);
+        return results
+            .filter(r => r.memory.category === category)
+            .slice(0, k);
+    }
+    getMemoriesByChapter(chapterNumber) {
+        return Array.from(this.memories.values())
+            .filter(m => m.chapterNumber === chapterNumber);
+    }
+    getAllMemories() {
+        return Array.from(this.memories.values());
+    }
+    async generateEmbedding(text) {
+        // Check if we should use mock embeddings (for testing without OpenAI)
+        if (process.env.USE_MOCK_EMBEDDINGS === 'true') {
+            return this.generateMockEmbedding(text);
+        }
+        const llm = (0, client_js_1.getLLM)();
+        const openai = llm.provider;
+        // Access the underlying OpenAI client for embeddings
+        const client = openai.client;
+        try {
+            const response = await client.embeddings.create({
+                model: 'text-embedding-3-small',
+                input: text,
+            });
+            return response.data[0].embedding;
+        }
+        catch (error) {
+            // Fall back to mock embeddings if the API fails (e.g., DeepSeek doesn't support embeddings)
+            console.log('  [VectorStore] Using mock embeddings (API unavailable)');
+            return this.generateMockEmbedding(text);
+        }
+    }
+    generateMockEmbedding(text) {
+        // Generate a deterministic mock embedding based on text content
+        // This is NOT for production - just for testing without OpenAI API
+        const embedding = [];
+        let seed = 0;
+        for (let i = 0; i < text.length; i++) {
+            seed += text.charCodeAt(i);
+        }
+        for (let i = 0; i < this.dimension; i++) {
+            // Simple pseudo-random based on seed
+            seed = (seed * 9301 + 49297) % 233280;
+            embedding.push((seed / 233280) * 2 - 1); // Range: -1 to 1
+        }
+        // Normalize the vector
+        const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+        return embedding.map(val => val / norm);
+    }
+    // Serialize for persistence
+    serialize() {
+        return JSON.stringify({
+            storyId: this.storyId,
+            nextId: this.nextId,
+            memories: Array.from(this.memories.entries()),
+        });
+    }
+    // Deserialize from saved state
+    async load(data) {
+        const parsed = JSON.parse(data);
+        this.memories = new Map(parsed.memories);
+        this.nextId = parsed.nextId || this.memories.size;
+        // Rebuild HNSW index
+        await this.initialize();
+        for (const [id, memory] of this.memories) {
+            if (memory.embedding) {
+                this.index.addPoint(memory.embedding, id);
+            }
+        }
+    }
+}
+exports.VectorStore = VectorStore;
+// Factory for story-specific stores
+const stores = new Map();
+function getVectorStore(storyId) {
+    if (!stores.has(storyId)) {
+        stores.set(storyId, new VectorStore(storyId));
+    }
+    return stores.get(storyId);
+}
+function clearVectorStore(storyId) {
+    stores.delete(storyId);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vectorStore.js","sourceRoot":"","sources":["../../src/memory/vectorStore.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport { HierarchicalNSW } from 'hnswlib-node';\r\n\r\nexport interface NarrativeMemory {\r\n  id: number;\r\n  storyId: string;\r\n  chapterNumber: number;\r\n  content: string;\r\n  category: 'event' | 'character' | 'world' | 'plot';\r\n  timestamp: Date;\r\n  embedding?: number[];\r\n}\r\n\r\nexport interface MemorySearchResult {\r\n  memory: NarrativeMemory;\r\n  score: number;\r\n}\r\n\r\nexport class VectorStore {\r\n  private index: HierarchicalNSW | null = null;\r\n  private memories: Map<number, NarrativeMemory> = new Map();\r\n  private dimension: number = 1536; // text-embedding-3-small dimension\r\n  private storyId: string;\r\n  private nextId: number = 0;\r\n\r\n  constructor(storyId: string) {\r\n    this.storyId = storyId;\r\n  }\r\n\r\n  async initialize(maxElements: number = 10000): Promise<void> {\r\n    this.index = new HierarchicalNSW('cosine', this.dimension);\r\n    this.index.initIndex(maxElements, 16, 200);\r\n    this.nextId = 0;\r\n    this.memories.clear();\r\n  }\r\n\r\n  /**\r\n   * Resize the index to accommodate more memories\r\n   */\r\n  resizeIndex(newMaxElements: number): void {\r\n    if (!this.index) {\r\n      throw new Error('VectorStore not initialized. Call initialize() first.');\r\n    }\r\n    \r\n    if (newMaxElements <= this.memories.size) {\r\n      return; // No need to resize\r\n    }\r\n    \r\n    this.index.resizeIndex(newMaxElements);\r\n  }\r\n\r\n  /**\r\n   * Ensure capacity for upcoming memories\r\n   */\r\n  ensureCapacity(additionalMemories: number): void {\r\n    const requiredCapacity = this.memories.size + additionalMemories;\r\n    const currentCapacity = this.index?.getMaxElements() || 0;\r\n    \r\n    if (requiredCapacity > currentCapacity) {\r\n      // Add 50% more capacity or use required, whichever is larger\r\n      const newCapacity = Math.max(Math.floor(currentCapacity * 1.5), requiredCapacity);\r\n      this.resizeIndex(newCapacity);\r\n    }\r\n  }\r\n\r\n  async addMemory(memory: Omit<NarrativeMemory, 'id' | 'embedding'>): Promise<NarrativeMemory> {\r\n    if (!this.index) {\r\n      throw new Error('VectorStore not initialized. Call initialize() first.');\r\n    }\r\n\r\n    // Auto-resize if we're near capacity (add 50% more)\r\n    const currentCapacity = this.index.getMaxElements();\r\n    if (this.memories.size >= currentCapacity - 1) {\r\n      this.resizeIndex(Math.floor(currentCapacity * 1.5));\r\n    }\r\n\r\n    const id = this.nextId++;\r\n    \r\n    // Generate embedding using OpenAI\r\n    const embedding = await this.generateEmbedding(memory.content);\r\n    \r\n    const fullMemory: NarrativeMemory = {\r\n      ...memory,\r\n      id,\r\n      embedding,\r\n    };\r\n\r\n    // Add to HNSW index\r\n    this.index.addPoint(embedding, id);\r\n    this.memories.set(id, fullMemory);\r\n\r\n    return fullMemory;\r\n  }\r\n\r\n  async searchSimilar(query: string, k: number = 5): Promise<MemorySearchResult[]> {\r\n    if (!this.index) {\r\n      throw new Error('VectorStore not initialized. Call initialize() first.');\r\n    }\r\n\r\n    const queryEmbedding = await this.generateEmbedding(query);\r\n    const results = this.index.searchKnn(queryEmbedding, k);\r\n\r\n    return results.neighbors.map((id: number, i: number) => ({\r\n      memory: this.memories.get(id)!,\r\n      score: results.distances[i],\r\n    }));\r\n  }\r\n\r\n  async searchByCategory(query: string, category: NarrativeMemory['category'], k: number = 5): Promise<MemorySearchResult[]> {\r\n    const results = await this.searchSimilar(query, k * 2);\r\n    return results\r\n      .filter(r => r.memory.category === category)\r\n      .slice(0, k);\r\n  }\r\n\r\n  getMemoriesByChapter(chapterNumber: number): NarrativeMemory[] {\r\n    return Array.from(this.memories.values())\r\n      .filter(m => m.chapterNumber === chapterNumber);\r\n  }\r\n\r\n  getAllMemories(): NarrativeMemory[] {\r\n    return Array.from(this.memories.values());\r\n  }\r\n\r\n  private async generateEmbedding(text: string): Promise<number[]> {\r\n    // Check if we should use mock embeddings (for testing without OpenAI)\r\n    if (process.env.USE_MOCK_EMBEDDINGS === 'true') {\r\n      return this.generateMockEmbedding(text);\r\n    }\r\n\r\n    const llm = getLLM();\r\n    const openai = (llm as any).provider;\r\n    \r\n    // Access the underlying OpenAI client for embeddings\r\n    const client = (openai as any).client;\r\n    \r\n    try {\r\n      const response = await client.embeddings.create({\r\n        model: 'text-embedding-3-small',\r\n        input: text,\r\n      });\r\n      return response.data[0].embedding;\r\n    } catch (error) {\r\n      // Fall back to mock embeddings if the API fails (e.g., DeepSeek doesn't support embeddings)\r\n      console.log('  [VectorStore] Using mock embeddings (API unavailable)');\r\n      return this.generateMockEmbedding(text);\r\n    }\r\n  }\r\n\r\n  private generateMockEmbedding(text: string): number[] {\r\n    // Generate a deterministic mock embedding based on text content\r\n    // This is NOT for production - just for testing without OpenAI API\r\n    const embedding: number[] = [];\r\n    let seed = 0;\r\n    for (let i = 0; i < text.length; i++) {\r\n      seed += text.charCodeAt(i);\r\n    }\r\n    \r\n    for (let i = 0; i < this.dimension; i++) {\r\n      // Simple pseudo-random based on seed\r\n      seed = (seed * 9301 + 49297) % 233280;\r\n      embedding.push((seed / 233280) * 2 - 1); // Range: -1 to 1\r\n    }\r\n    \r\n    // Normalize the vector\r\n    const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));\r\n    return embedding.map(val => val / norm);\r\n  }\r\n\r\n  // Serialize for persistence\r\n  serialize(): string {\r\n    return JSON.stringify({\r\n      storyId: this.storyId,\r\n      nextId: this.nextId,\r\n      memories: Array.from(this.memories.entries()),\r\n    });\r\n  }\r\n\r\n  // Deserialize from saved state\r\n  async load(data: string): Promise<void> {\r\n    const parsed = JSON.parse(data);\r\n    this.memories = new Map(parsed.memories);\r\n    this.nextId = parsed.nextId || this.memories.size;\r\n    \r\n    // Rebuild HNSW index\r\n    await this.initialize();\r\n    for (const [id, memory] of this.memories) {\r\n      if (memory.embedding) {\r\n        this.index!.addPoint(memory.embedding, id);\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n// Factory for story-specific stores\r\nconst stores: Map<string, VectorStore> = new Map();\r\n\r\nexport function getVectorStore(storyId: string): VectorStore {\r\n  if (!stores.has(storyId)) {\r\n    stores.set(storyId, new VectorStore(storyId));\r\n  }\r\n  return stores.get(storyId)!;\r\n}\r\n\r\nexport function clearVectorStore(storyId: string): void {\r\n  stores.delete(storyId);\r\n}\r\n"]}

package/dist/pipeline/generateChapter.d.ts

@@ -0,0 +1,17 @@
+import type { GenerationContext, Chapter, ChapterSummary } from '../types/index.js';
+import type { CanonStore } from '../memory/canonStore.js';
+import type { VectorStore } from '../memory/vectorStore.js';
+export interface GenerateChapterResult {
+    chapter: Chapter;
+    summary: ChapterSummary;
+    violations: string[];
+    memoriesExtracted: number;
+}
+export interface GenerateChapterOptions {
+    canon?: CanonStore;
+    vectorStore?: VectorStore;
+    validateCanon?: boolean;
+    maxContinuationAttempts?: number;
+    retrieveMemories?: boolean;
+}
+export declare function generateChapter(context: GenerationContext, options?: GenerateChapterOptions): Promise<GenerateChapterResult>;