@narrative-os/engine 0.1.0

package/dist/memory/canonStore.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCanonStore = createCanonStore;
+exports.extractCanonFromBible = extractCanonFromBible;
+exports.addFact = addFact;
+exports.getFactsByCategory = getFactsByCategory;
+exports.getFact = getFact;
+exports.updateFact = updateFact;
+exports.formatCanonForPrompt = formatCanonForPrompt;
+function createCanonStore(storyId) {
+    return {
+        storyId,
+        facts: [],
+    };
+}
+function extractCanonFromBible(bible) {
+    const store = createCanonStore(bible.id);
+    for (const char of bible.characters) {
+        addFact(store, {
+            category: 'character',
+            subject: char.name,
+            attribute: 'role',
+            value: char.role,
+            chapterEstablished: 0,
+        });
+        if (char.background) {
+            addFact(store, {
+                category: 'character',
+                subject: char.name,
+                attribute: 'background',
+                value: char.background,
+                chapterEstablished: 0,
+            });
+        }
+    }
+    for (const thread of bible.plotThreads) {
+        addFact(store, {
+            category: 'plot',
+            subject: thread.name,
+            attribute: 'status',
+            value: thread.status,
+            chapterEstablished: 0,
+        });
+    }
+    return store;
+}
+function addFact(store, fact) {
+    const newFact = {
+        ...fact,
+        id: generateId(),
+    };
+    return {
+        ...store,
+        facts: [...store.facts, newFact],
+    };
+}
+function getFactsByCategory(store, category) {
+    return store.facts.filter(f => f.category === category);
+}
+function getFact(store, subject, attribute) {
+    return store.facts.find(f => f.subject === subject && f.attribute === attribute);
+}
+function updateFact(store, subject, attribute, value, chapter) {
+    const existingIndex = store.facts.findIndex(f => f.subject === subject && f.attribute === attribute);
+    if (existingIndex >= 0) {
+        const updatedFacts = [...store.facts];
+        updatedFacts[existingIndex] = {
+            ...updatedFacts[existingIndex],
+            value,
+            chapterEstablished: chapter,
+        };
+        return { ...store, facts: updatedFacts };
+    }
+    return addFact(store, {
+        category: 'plot',
+        subject,
+        attribute,
+        value,
+        chapterEstablished: chapter,
+    });
+}
+function formatCanonForPrompt(store) {
+    const lines = ['## Story Canon (NEVER contradict these facts)'];
+    const characters = getFactsByCategory(store, 'character');
+    if (characters.length > 0) {
+        lines.push('\n### Characters');
+        for (const fact of characters) {
+            lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);
+        }
+    }
+    const world = getFactsByCategory(store, 'world');
+    if (world.length > 0) {
+        lines.push('\n### World');
+        for (const fact of world) {
+            lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);
+        }
+    }
+    const plot = getFactsByCategory(store, 'plot');
+    if (plot.length > 0) {
+        lines.push('\n### Plot');
+        for (const fact of plot) {
+            lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);
+        }
+    }
+    return lines.join('\n');
+}
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canonStore.js","sourceRoot":"","sources":["../../src/memory/canonStore.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StoryBible } from '../types/index.js';\r\n\r\nexport interface CanonFact {\r\n  id: string;\r\n  category: 'character' | 'world' | 'plot' | 'timeline';\r\n  subject: string;\r\n  attribute: string;\r\n  value: string;\r\n  chapterEstablished: number;\r\n}\r\n\r\nexport interface CanonStore {\r\n  storyId: string;\r\n  facts: CanonFact[];\r\n}\r\n\r\nexport function createCanonStore(storyId: string): CanonStore {\r\n  return {\r\n    storyId,\r\n    facts: [],\r\n  };\r\n}\r\n\r\nexport function extractCanonFromBible(bible: StoryBible): CanonStore {\r\n  const store = createCanonStore(bible.id);\r\n\r\n  for (const char of bible.characters) {\r\n    addFact(store, {\r\n      category: 'character',\r\n      subject: char.name,\r\n      attribute: 'role',\r\n      value: char.role,\r\n      chapterEstablished: 0,\r\n    });\r\n\r\n    if (char.background) {\r\n      addFact(store, {\r\n        category: 'character',\r\n        subject: char.name,\r\n        attribute: 'background',\r\n        value: char.background,\r\n        chapterEstablished: 0,\r\n      });\r\n    }\r\n  }\r\n\r\n  for (const thread of bible.plotThreads) {\r\n    addFact(store, {\r\n      category: 'plot',\r\n      subject: thread.name,\r\n      attribute: 'status',\r\n      value: thread.status,\r\n      chapterEstablished: 0,\r\n    });\r\n  }\r\n\r\n  return store;\r\n}\r\n\r\nexport function addFact(store: CanonStore, fact: Omit<CanonFact, 'id'>): CanonStore {\r\n  const newFact: CanonFact = {\r\n    ...fact,\r\n    id: generateId(),\r\n  };\r\n  return {\r\n    ...store,\r\n    facts: [...store.facts, newFact],\r\n  };\r\n}\r\n\r\nexport function getFactsByCategory(store: CanonStore, category: CanonFact['category']): CanonFact[] {\r\n  return store.facts.filter(f => f.category === category);\r\n}\r\n\r\nexport function getFact(store: CanonStore, subject: string, attribute: string): CanonFact | undefined {\r\n  return store.facts.find(f => f.subject === subject && f.attribute === attribute);\r\n}\r\n\r\nexport function updateFact(store: CanonStore, subject: string, attribute: string, value: string, chapter: number): CanonStore {\r\n  const existingIndex = store.facts.findIndex(f => f.subject === subject && f.attribute === attribute);\r\n  \r\n  if (existingIndex >= 0) {\r\n    const updatedFacts = [...store.facts];\r\n    updatedFacts[existingIndex] = {\r\n      ...updatedFacts[existingIndex],\r\n      value,\r\n      chapterEstablished: chapter,\r\n    };\r\n    return { ...store, facts: updatedFacts };\r\n  }\r\n  \r\n  return addFact(store, {\r\n    category: 'plot',\r\n    subject,\r\n    attribute,\r\n    value,\r\n    chapterEstablished: chapter,\r\n  });\r\n}\r\n\r\nexport function formatCanonForPrompt(store: CanonStore): string {\r\n  const lines: string[] = ['## Story Canon (NEVER contradict these facts)'];\r\n  \r\n  const characters = getFactsByCategory(store, 'character');\r\n  if (characters.length > 0) {\r\n    lines.push('\\n### Characters');\r\n    for (const fact of characters) {\r\n      lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);\r\n    }\r\n  }\r\n  \r\n  const world = getFactsByCategory(store, 'world');\r\n  if (world.length > 0) {\r\n    lines.push('\\n### World');\r\n    for (const fact of world) {\r\n      lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);\r\n    }\r\n  }\r\n  \r\n  const plot = getFactsByCategory(store, 'plot');\r\n  if (plot.length > 0) {\r\n    lines.push('\\n### Plot');\r\n    for (const fact of plot) {\r\n      lines.push(`- ${fact.subject}: ${fact.attribute} = ${fact.value}`);\r\n    }\r\n  }\r\n  \r\n  return lines.join('\\n');\r\n}\r\n\r\nfunction generateId(): string {\r\n  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;\r\n}\r\n"]}

package/dist/memory/memoryRetriever.d.ts

@@ -0,0 +1,28 @@
+import { VectorStore, NarrativeMemory } from './vectorStore.js';
+import type { StoryBible, StoryState } from '../types/index.js';
+export interface RetrievalContext {
+    bible: StoryBible;
+    state: StoryState;
+    currentChapter: number;
+    query?: string;
+}
+export interface RetrievedMemory {
+    memory: NarrativeMemory;
+    relevance: number;
+    reason: string;
+}
+export declare class MemoryRetriever {
+    private vectorStore;
+    constructor(vectorStore: VectorStore);
+    retrieveForChapter(context: RetrievalContext, k?: number): Promise<RetrievedMemory[]>;
+    retrieveForCharacter(characterName: string, context: string, k?: number): Promise<RetrievedMemory[]>;
+    retrieveForPlotThread(plotThreadId: string, bible: StoryBible, k?: number): Promise<RetrievedMemory[]>;
+    retrieveRelevantEvents(query: string, k?: number): Promise<RetrievedMemory[]>;
+    formatMemoriesForPrompt(memories: RetrievedMemory[]): string;
+    private generateContextualQuery;
+    private rerankMemories;
+    private inferRelevanceReason;
+    private groupByCategory;
+    private capitalize;
+}
+export declare function createMemoryRetriever(vectorStore: VectorStore): MemoryRetriever;

package/dist/memory/memoryRetriever.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRetriever = void 0;
+exports.createMemoryRetriever = createMemoryRetriever;
+class MemoryRetriever {
+    vectorStore;
+    constructor(vectorStore) {
+        this.vectorStore = vectorStore;
+    }
+    async retrieveForChapter(context, k = 5) {
+        const { bible, state, currentChapter, query } = context;
+        // Generate a contextual query if none provided
+        const searchQuery = query || this.generateContextualQuery(bible, state, currentChapter);
+        // Search for similar memories
+        const results = await this.vectorStore.searchSimilar(searchQuery, k * 2);
+        // Filter out memories from the current chapter (can't recall what hasn't happened yet)
+        const pastMemories = results.filter(r => r.memory.chapterNumber < currentChapter);
+        // Re-rank and filter for relevance
+        const ranked = await this.rerankMemories(searchQuery, pastMemories, k);
+        return ranked;
+    }
+    async retrieveForCharacter(characterName, context, k = 3) {
+        const query = `Character ${characterName}: ${context}`;
+        const results = await this.vectorStore.searchByCategory(query, 'character', k * 2);
+        // Filter for memories actually about this character
+        const characterMemories = results.filter(r => r.memory.content.toLowerCase().includes(characterName.toLowerCase()));
+        return characterMemories.slice(0, k).map(r => ({
+            memory: r.memory,
+            relevance: r.score,
+            reason: 'Character-relevant memory',
+        }));
+    }
+    async retrieveForPlotThread(plotThreadId, bible, k = 3) {
+        const plotThread = bible.plotThreads.find(p => p.id === plotThreadId);
+        if (!plotThread)
+            return [];
+        const query = `Plot thread "${plotThread.name}": ${plotThread.description}`;
+        const results = await this.vectorStore.searchByCategory(query, 'plot', k * 2);
+        return results.slice(0, k).map(r => ({
+            memory: r.memory,
+            relevance: r.score,
+            reason: `Relevant to plot thread: ${plotThread.name}`,
+        }));
+    }
+    async retrieveRelevantEvents(query, k = 5) {
+        const results = await this.vectorStore.searchByCategory(query, 'event', k);
+        return results.map(r => ({
+            memory: r.memory,
+            relevance: r.score,
+            reason: 'Relevant past event',
+        }));
+    }
+    formatMemoriesForPrompt(memories) {
+        if (memories.length === 0) {
+            return '';
+        }
+        const sections = [];
+        // Group by category
+        const byCategory = this.groupByCategory(memories);
+        for (const [category, items] of Object.entries(byCategory)) {
+            if (items.length > 0) {
+                sections.push(`### ${this.capitalize(category)} Memories\n${items.map(m => `- ${m.memory.content} (Ch. ${m.memory.chapterNumber})`).join('\n')}`);
+            }
+        }
+        return `## Relevant Past Memories\n\n${sections.join('\n\n')}`;
+    }
+    generateContextualQuery(bible, state, currentChapter) {
+        const progress = currentChapter / bible.targetChapters;
+        const activeThreads = bible.plotThreads
+            .filter(p => state.activePlotThreads.includes(p.id))
+            .map(p => p.name)
+            .join(', ');
+        return `Chapter ${currentChapter} of ${bible.title}. Genre: ${bible.genre}. ` +
+            `Story progress: ${Math.round(progress * 100)}%. ` +
+            `Active plot threads: ${activeThreads}. ` +
+            `Premise: ${bible.premise.substring(0, 200)}`;
+    }
+    async rerankMemories(query, candidates, topK) {
+        // Simple re-ranking: use the vector similarity score directly
+        // In a more sophisticated version, we could use an LLM to judge relevance
+        return candidates
+            .slice(0, topK)
+            .map(r => ({
+            memory: r.memory,
+            relevance: r.score,
+            reason: this.inferRelevanceReason(r.memory),
+        }));
+    }
+    inferRelevanceReason(memory) {
+        switch (memory.category) {
+            case 'event':
+                return 'Relevant past event';
+            case 'character':
+                return 'Character background or development';
+            case 'world':
+                return 'World-building detail';
+            case 'plot':
+                return 'Plot-relevant information';
+            default:
+                return 'Relevant memory';
+        }
+    }
+    groupByCategory(memories) {
+        const grouped = {
+            event: [],
+            character: [],
+            world: [],
+            plot: [],
+        };
+        for (const memory of memories) {
+            const cat = memory.memory.category;
+            if (!grouped[cat])
+                grouped[cat] = [];
+            grouped[cat].push(memory);
+        }
+        return grouped;
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+exports.MemoryRetriever = MemoryRetriever;
+function createMemoryRetriever(vectorStore) {
+    return new MemoryRetriever(vectorStore);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"memoryRetriever.js","sourceRoot":"","sources":["../../src/memory/memoryRetriever.ts"],"names":[],"mappings":"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","sourcesContent":["import { VectorStore, NarrativeMemory, MemorySearchResult } from './vectorStore.js';\r\nimport { getLLM } from '../llm/client.js';\r\nimport type { StoryBible, StoryState } from '../types/index.js';\r\n\r\nexport interface RetrievalContext {\r\n  bible: StoryBible;\r\n  state: StoryState;\r\n  currentChapter: number;\r\n  query?: string;\r\n}\r\n\r\nexport interface RetrievedMemory {\r\n  memory: NarrativeMemory;\r\n  relevance: number;\r\n  reason: string;\r\n}\r\n\r\nexport class MemoryRetriever {\r\n  private vectorStore: VectorStore;\r\n\r\n  constructor(vectorStore: VectorStore) {\r\n    this.vectorStore = vectorStore;\r\n  }\r\n\r\n  async retrieveForChapter(context: RetrievalContext, k: number = 5): Promise<RetrievedMemory[]> {\r\n    const { bible, state, currentChapter, query } = context;\r\n\r\n    // Generate a contextual query if none provided\r\n    const searchQuery = query || this.generateContextualQuery(bible, state, currentChapter);\r\n\r\n    // Search for similar memories\r\n    const results = await this.vectorStore.searchSimilar(searchQuery, k * 2);\r\n\r\n    // Filter out memories from the current chapter (can't recall what hasn't happened yet)\r\n    const pastMemories = results.filter(r => r.memory.chapterNumber < currentChapter);\r\n\r\n    // Re-rank and filter for relevance\r\n    const ranked = await this.rerankMemories(searchQuery, pastMemories, k);\r\n\r\n    return ranked;\r\n  }\r\n\r\n  async retrieveForCharacter(characterName: string, context: string, k: number = 3): Promise<RetrievedMemory[]> {\r\n    const query = `Character ${characterName}: ${context}`;\r\n    \r\n    const results = await this.vectorStore.searchByCategory(query, 'character', k * 2);\r\n    \r\n    // Filter for memories actually about this character\r\n    const characterMemories = results.filter(r => \r\n      r.memory.content.toLowerCase().includes(characterName.toLowerCase())\r\n    );\r\n\r\n    return characterMemories.slice(0, k).map(r => ({\r\n      memory: r.memory,\r\n      relevance: r.score,\r\n      reason: 'Character-relevant memory',\r\n    }));\r\n  }\r\n\r\n  async retrieveForPlotThread(plotThreadId: string, bible: StoryBible, k: number = 3): Promise<RetrievedMemory[]> {\r\n    const plotThread = bible.plotThreads.find(p => p.id === plotThreadId);\r\n    if (!plotThread) return [];\r\n\r\n    const query = `Plot thread \"${plotThread.name}\": ${plotThread.description}`;\r\n    \r\n    const results = await this.vectorStore.searchByCategory(query, 'plot', k * 2);\r\n\r\n    return results.slice(0, k).map(r => ({\r\n      memory: r.memory,\r\n      relevance: r.score,\r\n      reason: `Relevant to plot thread: ${plotThread.name}`,\r\n    }));\r\n  }\r\n\r\n  async retrieveRelevantEvents(query: string, k: number = 5): Promise<RetrievedMemory[]> {\r\n    const results = await this.vectorStore.searchByCategory(query, 'event', k);\r\n\r\n    return results.map(r => ({\r\n      memory: r.memory,\r\n      relevance: r.score,\r\n      reason: 'Relevant past event',\r\n    }));\r\n  }\r\n\r\n  formatMemoriesForPrompt(memories: RetrievedMemory[]): string {\r\n    if (memories.length === 0) {\r\n      return '';\r\n    }\r\n\r\n    const sections: string[] = [];\r\n    \r\n    // Group by category\r\n    const byCategory = this.groupByCategory(memories);\r\n\r\n    for (const [category, items] of Object.entries(byCategory)) {\r\n      if (items.length > 0) {\r\n        sections.push(`### ${this.capitalize(category)} Memories\\n${items.map(m => `- ${m.memory.content} (Ch. ${m.memory.chapterNumber})`).join('\\n')}`);\r\n      }\r\n    }\r\n\r\n    return `## Relevant Past Memories\\n\\n${sections.join('\\n\\n')}`;\r\n  }\r\n\r\n  private generateContextualQuery(bible: StoryBible, state: StoryState, currentChapter: number): string {\r\n    const progress = currentChapter / bible.targetChapters;\r\n    const activeThreads = bible.plotThreads\r\n      .filter(p => state.activePlotThreads.includes(p.id))\r\n      .map(p => p.name)\r\n      .join(', ');\r\n\r\n    return `Chapter ${currentChapter} of ${bible.title}. Genre: ${bible.genre}. ` +\r\n           `Story progress: ${Math.round(progress * 100)}%. ` +\r\n           `Active plot threads: ${activeThreads}. ` +\r\n           `Premise: ${bible.premise.substring(0, 200)}`;\r\n  }\r\n\r\n  private async rerankMemories(\r\n    query: string, \r\n    candidates: MemorySearchResult[], \r\n    topK: number\r\n  ): Promise<RetrievedMemory[]> {\r\n    // Simple re-ranking: use the vector similarity score directly\r\n    // In a more sophisticated version, we could use an LLM to judge relevance\r\n    \r\n    return candidates\r\n      .slice(0, topK)\r\n      .map(r => ({\r\n        memory: r.memory,\r\n        relevance: r.score,\r\n        reason: this.inferRelevanceReason(r.memory),\r\n      }));\r\n  }\r\n\r\n  private inferRelevanceReason(memory: NarrativeMemory): string {\r\n    switch (memory.category) {\r\n      case 'event':\r\n        return 'Relevant past event';\r\n      case 'character':\r\n        return 'Character background or development';\r\n      case 'world':\r\n        return 'World-building detail';\r\n      case 'plot':\r\n        return 'Plot-relevant information';\r\n      default:\r\n        return 'Relevant memory';\r\n    }\r\n  }\r\n\r\n  private groupByCategory(memories: RetrievedMemory[]): Record<string, RetrievedMemory[]> {\r\n    const grouped: Record<string, RetrievedMemory[]> = {\r\n      event: [],\r\n      character: [],\r\n      world: [],\r\n      plot: [],\r\n    };\r\n\r\n    for (const memory of memories) {\r\n      const cat = memory.memory.category;\r\n      if (!grouped[cat]) grouped[cat] = [];\r\n      grouped[cat].push(memory);\r\n    }\r\n\r\n    return grouped;\r\n  }\r\n\r\n  private capitalize(str: string): string {\r\n    return str.charAt(0).toUpperCase() + str.slice(1);\r\n  }\r\n}\r\n\r\nexport function createMemoryRetriever(vectorStore: VectorStore): MemoryRetriever {\r\n  return new MemoryRetriever(vectorStore);\r\n}\r\n"]}

package/dist/memory/stateUpdater.d.ts

@@ -0,0 +1,49 @@
+import type { Chapter, StoryBible } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+import type { VectorStore } from './vectorStore.js';
+import type { CanonStore } from './canonStore.js';
+import { ConstraintGraph } from '../constraints/constraintGraph.js';
+export interface StateUpdateResult {
+    structuredState: StoryStructuredState;
+    memoriesAdded: number;
+    canonFactsAdded: number;
+    graphUpdated: boolean;
+    changes: StateChange[];
+}
+export interface StateChange {
+    type: 'character' | 'plot' | 'world' | 'canon' | 'memory';
+    description: string;
+    chapter: number;
+}
+export interface UpdateContext {
+    chapter: Chapter;
+    bible: StoryBible;
+    currentState: StoryStructuredState;
+    canon: CanonStore;
+    vectorStore: VectorStore;
+    constraintGraph: ConstraintGraph;
+}
+export declare class StateUpdaterPipeline {
+    /**
+     * Run the complete post-chapter update pipeline
+     */
+    update(context: UpdateContext): Promise<StateUpdateResult>;
+    /**
+     * Extract state changes from chapter
+     */
+    private extractChanges;
+    /**
+     * Extract narrative memories from chapter
+     */
+    private extractMemories;
+    /**
+     * Quick update without LLM (for testing)
+     */
+    quickUpdate(context: UpdateContext): Promise<StateUpdateResult>;
+    /**
+     * Format update result
+     */
+    formatResult(result: StateUpdateResult): string;
+    private sanitizeId;
+}
+export declare const stateUpdaterPipeline: StateUpdaterPipeline;