@narrative-os/engine 0.1.0

package/dist/world/worldState.d.ts

@@ -0,0 +1,93 @@
+import type { CharacterAgent } from './characterAgent.js';
+import type { WorldEvent, EventResolution } from './eventResolver.js';
+export interface Location {
+    id: string;
+    name: string;
+    description: string;
+    connectedTo: string[];
+    characters: string[];
+    items: string[];
+    events: string[];
+}
+export interface WorldState {
+    storyId: string;
+    currentChapter: number;
+    locations: Map<string, Location>;
+    characters: Map<string, CharacterAgent>;
+    events: WorldEvent[];
+    history: string[];
+    globalState: Record<string, any>;
+}
+export declare class WorldStateManager {
+    private state;
+    constructor(storyId: string);
+    /**
+     * Initialize world from story bible
+     */
+    initialize(setting: string, initialCharacters: CharacterAgent[]): void;
+    /**
+     * Add a new location
+     */
+    addLocation(id: string, name: string, description: string, connectedTo?: string[]): Location;
+    /**
+     * Connect two locations
+     */
+    connectLocations(locId1: string, locId2: string): void;
+    /**
+     * Move character between locations
+     */
+    moveCharacter(characterName: string, toLocationId: string): boolean;
+    /**
+     * Get character's current location
+     */
+    getCharacterLocation(characterName: string): Location | undefined;
+    /**
+     * Add character to world
+     */
+    addCharacter(character: CharacterAgent): void;
+    /**
+     * Get characters at a location
+     */
+    getCharactersAtLocation(locationId: string): CharacterAgent[];
+    /**
+     * Add event to world
+     */
+    addEvent(event: WorldEvent): void;
+    /**
+     * Process event resolutions and update world
+     */
+    applyResolutions(resolutions: EventResolution[]): void;
+    /**
+     * Advance to next chapter
+     */
+    advanceChapter(): void;
+    /**
+     * Set global state value
+     */
+    setGlobalState(key: string, value: any): void;
+    /**
+     * Get global state value
+     */
+    getGlobalState(key: string): any;
+    /**
+     * Add entry to world history
+     */
+    private addToHistory;
+    /**
+     * Get world state summary
+     */
+    getSummary(): string;
+    /**
+     * Get full world state
+     */
+    getState(): WorldState;
+    /**
+     * Serialize world state
+     */
+    serialize(): string;
+    /**
+     * Deserialize world state
+     */
+    load(data: string): void;
+}
+export declare function createWorldStateManager(storyId: string): WorldStateManager;

package/dist/world/worldState.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorldStateManager = void 0;
+exports.createWorldStateManager = createWorldStateManager;
+class WorldStateManager {
+    state;
+    constructor(storyId) {
+        this.state = {
+            storyId,
+            currentChapter: 0,
+            locations: new Map(),
+            characters: new Map(),
+            events: [],
+            history: [],
+            globalState: {},
+        };
+    }
+    /**
+     * Initialize world from story bible
+     */
+    initialize(setting, initialCharacters) {
+        // Create initial location from setting
+        const startingLocation = {
+            id: 'loc-start',
+            name: setting,
+            description: `The main setting of the story: ${setting}`,
+            connectedTo: [],
+            characters: initialCharacters.map(c => c.name),
+            items: [],
+            events: [],
+        };
+        this.state.locations.set(startingLocation.id, startingLocation);
+        // Add characters
+        for (const character of initialCharacters) {
+            this.state.characters.set(character.name, character);
+        }
+        this.addToHistory(`World initialized at ${setting} with ${initialCharacters.length} characters`);
+    }
+    /**
+     * Add a new location
+     */
+    addLocation(id, name, description, connectedTo = []) {
+        const location = {
+            id,
+            name,
+            description,
+            connectedTo,
+            characters: [],
+            items: [],
+            events: [],
+        };
+        this.state.locations.set(id, location);
+        this.addToHistory(`Location added: ${name}`);
+        return location;
+    }
+    /**
+     * Connect two locations
+     */
+    connectLocations(locId1, locId2) {
+        const loc1 = this.state.locations.get(locId1);
+        const loc2 = this.state.locations.get(locId2);
+        if (loc1 && loc2) {
+            if (!loc1.connectedTo.includes(locId2)) {
+                loc1.connectedTo.push(locId2);
+            }
+            if (!loc2.connectedTo.includes(locId1)) {
+                loc2.connectedTo.push(locId1);
+            }
+        }
+    }
+    /**
+     * Move character between locations
+     */
+    moveCharacter(characterName, toLocationId) {
+        const character = this.state.characters.get(characterName);
+        const fromLocation = this.getCharacterLocation(characterName);
+        const toLocation = this.state.locations.get(toLocationId);
+        if (!character || !toLocation)
+            return false;
+        // Remove from old location
+        if (fromLocation) {
+            fromLocation.characters = fromLocation.characters.filter(c => c !== characterName);
+        }
+        // Add to new location
+        if (!toLocation.characters.includes(characterName)) {
+            toLocation.characters.push(characterName);
+        }
+        // Update character location
+        character.location = toLocation.name;
+        this.addToHistory(`${characterName} moved to ${toLocation.name}`);
+        return true;
+    }
+    /**
+     * Get character's current location
+     */
+    getCharacterLocation(characterName) {
+        for (const location of this.state.locations.values()) {
+            if (location.characters.includes(characterName)) {
+                return location;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Add character to world
+     */
+    addCharacter(character) {
+        this.state.characters.set(character.name, character);
+        // Add to location
+        for (const location of this.state.locations.values()) {
+            if (location.name === character.location) {
+                if (!location.characters.includes(character.name)) {
+                    location.characters.push(character.name);
+                }
+                break;
+            }
+        }
+        this.addToHistory(`Character added: ${character.name}`);
+    }
+    /**
+     * Get characters at a location
+     */
+    getCharactersAtLocation(locationId) {
+        const location = this.state.locations.get(locationId);
+        if (!location)
+            return [];
+        return location.characters
+            .map(name => this.state.characters.get(name))
+            .filter((c) => c !== undefined);
+    }
+    /**
+     * Add event to world
+     */
+    addEvent(event) {
+        this.state.events.push(event);
+        // Add to location
+        const location = Array.from(this.state.locations.values())
+            .find(l => l.name === event.location);
+        if (location) {
+            location.events.push(event.id);
+        }
+        this.addToHistory(`Event: ${event.description}`);
+    }
+    /**
+     * Process event resolutions and update world
+     */
+    applyResolutions(resolutions) {
+        for (const resolution of resolutions) {
+            // Update event
+            const eventIndex = this.state.events.findIndex(e => e.id === resolution.event.id);
+            if (eventIndex >= 0) {
+                this.state.events[eventIndex] = resolution.event;
+            }
+            // Add to history
+            this.addToHistory(`Resolved: ${resolution.outcome}`);
+            // Apply consequences to characters
+            for (const characterName of resolution.affectedCharacters) {
+                const character = this.state.characters.get(characterName);
+                if (character) {
+                    // Could update emotional state, knowledge, etc. based on consequences
+                    // For now, just log it
+                }
+            }
+        }
+    }
+    /**
+     * Advance to next chapter
+     */
+    advanceChapter() {
+        this.state.currentChapter++;
+        this.addToHistory(`Chapter ${this.state.currentChapter} begins`);
+    }
+    /**
+     * Set global state value
+     */
+    setGlobalState(key, value) {
+        this.state.globalState[key] = value;
+    }
+    /**
+     * Get global state value
+     */
+    getGlobalState(key) {
+        return this.state.globalState[key];
+    }
+    /**
+     * Add entry to world history
+     */
+    addToHistory(entry) {
+        const timestamp = `Ch${this.state.currentChapter}`;
+        this.state.history.push(`[${timestamp}] ${entry}`);
+    }
+    /**
+     * Get world state summary
+     */
+    getSummary() {
+        const lines = ['## World State'];
+        lines.push(`\n**Current Chapter:** ${this.state.currentChapter}`);
+        lines.push(`**Locations:** ${this.state.locations.size}`);
+        lines.push(`**Characters:** ${this.state.characters.size}`);
+        lines.push(`**Active Events:** ${this.state.events.filter(e => !e.resolved).length}`);
+        // Location summary
+        lines.push('\n### Locations');
+        for (const location of this.state.locations.values()) {
+            lines.push(`- **${location.name}**: ${location.characters.length} characters`);
+        }
+        // Character summary
+        lines.push('\n### Character Locations');
+        for (const character of this.state.characters.values()) {
+            lines.push(`- ${character.name}: ${character.location} (${character.emotionalState})`);
+        }
+        // Recent history
+        lines.push('\n### Recent History');
+        for (const entry of this.state.history.slice(-5)) {
+            lines.push(`- ${entry}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get full world state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Serialize world state
+     */
+    serialize() {
+        return JSON.stringify({
+            storyId: this.state.storyId,
+            currentChapter: this.state.currentChapter,
+            locations: Array.from(this.state.locations.entries()),
+            characters: Array.from(this.state.characters.entries()),
+            events: this.state.events,
+            history: this.state.history,
+            globalState: this.state.globalState,
+        });
+    }
+    /**
+     * Deserialize world state
+     */
+    load(data) {
+        const parsed = JSON.parse(data);
+        this.state = {
+            storyId: parsed.storyId,
+            currentChapter: parsed.currentChapter,
+            locations: new Map(parsed.locations),
+            characters: new Map(parsed.characters),
+            events: parsed.events,
+            history: parsed.history,
+            globalState: parsed.globalState,
+        };
+    }
+}
+exports.WorldStateManager = WorldStateManager;
+function createWorldStateManager(storyId) {
+    return new WorldStateManager(storyId);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worldState.js","sourceRoot":"","sources":["../../src/world/worldState.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CharacterAgent } from './characterAgent.js';\r\nimport type { WorldEvent, EventResolution } from './eventResolver.js';\r\n\r\nexport interface Location {\r\n  id: string;\r\n  name: string;\r\n  description: string;\r\n  connectedTo: string[];\r\n  characters: string[];\r\n  items: string[];\r\n  events: string[];\r\n}\r\n\r\nexport interface WorldState {\r\n  storyId: string;\r\n  currentChapter: number;\r\n  locations: Map<string, Location>;\r\n  characters: Map<string, CharacterAgent>;\r\n  events: WorldEvent[];\r\n  history: string[];\r\n  globalState: Record<string, any>;\r\n}\r\n\r\nexport class WorldStateManager {\r\n  private state: WorldState;\r\n  \r\n  constructor(storyId: string) {\r\n    this.state = {\r\n      storyId,\r\n      currentChapter: 0,\r\n      locations: new Map(),\r\n      characters: new Map(),\r\n      events: [],\r\n      history: [],\r\n      globalState: {},\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Initialize world from story bible\r\n   */\r\n  initialize(setting: string, initialCharacters: CharacterAgent[]): void {\r\n    // Create initial location from setting\r\n    const startingLocation: Location = {\r\n      id: 'loc-start',\r\n      name: setting,\r\n      description: `The main setting of the story: ${setting}`,\r\n      connectedTo: [],\r\n      characters: initialCharacters.map(c => c.name),\r\n      items: [],\r\n      events: [],\r\n    };\r\n    \r\n    this.state.locations.set(startingLocation.id, startingLocation);\r\n    \r\n    // Add characters\r\n    for (const character of initialCharacters) {\r\n      this.state.characters.set(character.name, character);\r\n    }\r\n    \r\n    this.addToHistory(`World initialized at ${setting} with ${initialCharacters.length} characters`);\r\n  }\r\n  \r\n  /**\r\n   * Add a new location\r\n   */\r\n  addLocation(\r\n    id: string,\r\n    name: string,\r\n    description: string,\r\n    connectedTo: string[] = []\r\n  ): Location {\r\n    const location: Location = {\r\n      id,\r\n      name,\r\n      description,\r\n      connectedTo,\r\n      characters: [],\r\n      items: [],\r\n      events: [],\r\n    };\r\n    \r\n    this.state.locations.set(id, location);\r\n    this.addToHistory(`Location added: ${name}`);\r\n    \r\n    return location;\r\n  }\r\n  \r\n  /**\r\n   * Connect two locations\r\n   */\r\n  connectLocations(locId1: string, locId2: string): void {\r\n    const loc1 = this.state.locations.get(locId1);\r\n    const loc2 = this.state.locations.get(locId2);\r\n    \r\n    if (loc1 && loc2) {\r\n      if (!loc1.connectedTo.includes(locId2)) {\r\n        loc1.connectedTo.push(locId2);\r\n      }\r\n      if (!loc2.connectedTo.includes(locId1)) {\r\n        loc2.connectedTo.push(locId1);\r\n      }\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Move character between locations\r\n   */\r\n  moveCharacter(characterName: string, toLocationId: string): boolean {\r\n    const character = this.state.characters.get(characterName);\r\n    const fromLocation = this.getCharacterLocation(characterName);\r\n    const toLocation = this.state.locations.get(toLocationId);\r\n    \r\n    if (!character || !toLocation) return false;\r\n    \r\n    // Remove from old location\r\n    if (fromLocation) {\r\n      fromLocation.characters = fromLocation.characters.filter(c => c !== characterName);\r\n    }\r\n    \r\n    // Add to new location\r\n    if (!toLocation.characters.includes(characterName)) {\r\n      toLocation.characters.push(characterName);\r\n    }\r\n    \r\n    // Update character location\r\n    character.location = toLocation.name;\r\n    \r\n    this.addToHistory(`${characterName} moved to ${toLocation.name}`);\r\n    return true;\r\n  }\r\n  \r\n  /**\r\n   * Get character's current location\r\n   */\r\n  getCharacterLocation(characterName: string): Location | undefined {\r\n    for (const location of this.state.locations.values()) {\r\n      if (location.characters.includes(characterName)) {\r\n        return location;\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n  \r\n  /**\r\n   * Add character to world\r\n   */\r\n  addCharacter(character: CharacterAgent): void {\r\n    this.state.characters.set(character.name, character);\r\n    \r\n    // Add to location\r\n    for (const location of this.state.locations.values()) {\r\n      if (location.name === character.location) {\r\n        if (!location.characters.includes(character.name)) {\r\n          location.characters.push(character.name);\r\n        }\r\n        break;\r\n      }\r\n    }\r\n    \r\n    this.addToHistory(`Character added: ${character.name}`);\r\n  }\r\n  \r\n  /**\r\n   * Get characters at a location\r\n   */\r\n  getCharactersAtLocation(locationId: string): CharacterAgent[] {\r\n    const location = this.state.locations.get(locationId);\r\n    if (!location) return [];\r\n    \r\n    return location.characters\r\n      .map(name => this.state.characters.get(name))\r\n      .filter((c): c is CharacterAgent => c !== undefined);\r\n  }\r\n  \r\n  /**\r\n   * Add event to world\r\n   */\r\n  addEvent(event: WorldEvent): void {\r\n    this.state.events.push(event);\r\n    \r\n    // Add to location\r\n    const location = Array.from(this.state.locations.values())\r\n      .find(l => l.name === event.location);\r\n    if (location) {\r\n      location.events.push(event.id);\r\n    }\r\n    \r\n    this.addToHistory(`Event: ${event.description}`);\r\n  }\r\n  \r\n  /**\r\n   * Process event resolutions and update world\r\n   */\r\n  applyResolutions(resolutions: EventResolution[]): void {\r\n    for (const resolution of resolutions) {\r\n      // Update event\r\n      const eventIndex = this.state.events.findIndex(e => e.id === resolution.event.id);\r\n      if (eventIndex >= 0) {\r\n        this.state.events[eventIndex] = resolution.event;\r\n      }\r\n      \r\n      // Add to history\r\n      this.addToHistory(`Resolved: ${resolution.outcome}`);\r\n      \r\n      // Apply consequences to characters\r\n      for (const characterName of resolution.affectedCharacters) {\r\n        const character = this.state.characters.get(characterName);\r\n        if (character) {\r\n          // Could update emotional state, knowledge, etc. based on consequences\r\n          // For now, just log it\r\n        }\r\n      }\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Advance to next chapter\r\n   */\r\n  advanceChapter(): void {\r\n    this.state.currentChapter++;\r\n    this.addToHistory(`Chapter ${this.state.currentChapter} begins`);\r\n  }\r\n  \r\n  /**\r\n   * Set global state value\r\n   */\r\n  setGlobalState(key: string, value: any): void {\r\n    this.state.globalState[key] = value;\r\n  }\r\n  \r\n  /**\r\n   * Get global state value\r\n   */\r\n  getGlobalState(key: string): any {\r\n    return this.state.globalState[key];\r\n  }\r\n  \r\n  /**\r\n   * Add entry to world history\r\n   */\r\n  private addToHistory(entry: string): void {\r\n    const timestamp = `Ch${this.state.currentChapter}`;\r\n    this.state.history.push(`[${timestamp}] ${entry}`);\r\n  }\r\n  \r\n  /**\r\n   * Get world state summary\r\n   */\r\n  getSummary(): string {\r\n    const lines: string[] = ['## World State'];\r\n    \r\n    lines.push(`\\n**Current Chapter:** ${this.state.currentChapter}`);\r\n    lines.push(`**Locations:** ${this.state.locations.size}`);\r\n    lines.push(`**Characters:** ${this.state.characters.size}`);\r\n    lines.push(`**Active Events:** ${this.state.events.filter(e => !e.resolved).length}`);\r\n    \r\n    // Location summary\r\n    lines.push('\\n### Locations');\r\n    for (const location of this.state.locations.values()) {\r\n      lines.push(`- **${location.name}**: ${location.characters.length} characters`);\r\n    }\r\n    \r\n    // Character summary\r\n    lines.push('\\n### Character Locations');\r\n    for (const character of this.state.characters.values()) {\r\n      lines.push(`- ${character.name}: ${character.location} (${character.emotionalState})`);\r\n    }\r\n    \r\n    // Recent history\r\n    lines.push('\\n### Recent History');\r\n    for (const entry of this.state.history.slice(-5)) {\r\n      lines.push(`- ${entry}`);\r\n    }\r\n    \r\n    return lines.join('\\n');\r\n  }\r\n  \r\n  /**\r\n   * Get full world state\r\n   */\r\n  getState(): WorldState {\r\n    return this.state;\r\n  }\r\n  \r\n  /**\r\n   * Serialize world state\r\n   */\r\n  serialize(): string {\r\n    return JSON.stringify({\r\n      storyId: this.state.storyId,\r\n      currentChapter: this.state.currentChapter,\r\n      locations: Array.from(this.state.locations.entries()),\r\n      characters: Array.from(this.state.characters.entries()),\r\n      events: this.state.events,\r\n      history: this.state.history,\r\n      globalState: this.state.globalState,\r\n    });\r\n  }\r\n  \r\n  /**\r\n   * Deserialize world state\r\n   */\r\n  load(data: string): void {\r\n    const parsed = JSON.parse(data);\r\n    this.state = {\r\n      storyId: parsed.storyId,\r\n      currentChapter: parsed.currentChapter,\r\n      locations: new Map(parsed.locations),\r\n      characters: new Map(parsed.characters),\r\n      events: parsed.events,\r\n      history: parsed.history,\r\n      globalState: parsed.globalState,\r\n    };\r\n  }\r\n}\r\n\r\nexport function createWorldStateManager(storyId: string): WorldStateManager {\r\n  return new WorldStateManager(storyId);\r\n}\r\n"]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@narrative-os/engine",
+  "version": "0.1.0",
+  "description": "Core narrative engine for AI-powered story generation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src/**/*.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "story",
+    "narrative",
+    "writing",
+    "llm",
+    "memory",
+    "hnsw"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/liwonder/NARRITIVE_OS.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "hnswlib-node": "^3.0.0",
+    "openai": "^4.52.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  }
+}