@narrative-os/engine 0.1.0

package/dist/constraints/constraintGraph.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintGraph = void 0;
+exports.createConstraintGraph = createConstraintGraph;
+class ConstraintGraph {
+    nodes = new Map();
+    edges = new Map();
+    adjacencyList = new Map();
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        this.nodes.set(node.id, node);
+        if (!this.adjacencyList.has(node.id)) {
+            this.adjacencyList.set(node.id, new Set());
+        }
+    }
+    /**
+     * Add an edge between nodes
+     */
+    addEdge(edge) {
+        // Validate nodes exist
+        if (!this.nodes.has(edge.from) || !this.nodes.has(edge.to)) {
+            throw new Error(`Cannot add edge: node not found (${edge.from} -> ${edge.to})`);
+        }
+        this.edges.set(edge.id, edge);
+        // Update adjacency list
+        const fromSet = this.adjacencyList.get(edge.from);
+        if (fromSet) {
+            fromSet.add(edge.to);
+        }
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Get all edges from a node
+     */
+    getEdgesFrom(nodeId) {
+        return Array.from(this.edges.values()).filter(e => e.from === nodeId);
+    }
+    /**
+     * Get all edges to a node
+     */
+    getEdgesTo(nodeId) {
+        return Array.from(this.edges.values()).filter(e => e.to === nodeId);
+    }
+    /**
+     * Get neighbors of a node
+     */
+    getNeighbors(nodeId) {
+        const neighborIds = this.adjacencyList.get(nodeId);
+        if (!neighborIds)
+            return [];
+        return Array.from(neighborIds)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /**
+     * Add character to graph
+     */
+    addCharacter(character, chapter) {
+        const charNode = {
+            id: `char-${character.name}`,
+            type: 'character',
+            label: character.name,
+            properties: {
+                emotionalState: character.emotionalState,
+                location: character.location,
+                goals: character.goals,
+            },
+            chapterEstablished: chapter,
+        };
+        this.addNode(charNode);
+        // Add location edge
+        this.addEdge({
+            id: `edge-${character.name}-loc`,
+            from: charNode.id,
+            to: `loc-${character.location}`,
+            type: 'located_at',
+            properties: { since: chapter },
+        });
+        // Add knowledge nodes and edges
+        for (const knowledge of character.knowledge) {
+            const factId = `fact-${this.sanitizeId(knowledge)}`;
+            if (!this.nodes.has(factId)) {
+                this.addNode({
+                    id: factId,
+                    type: 'fact',
+                    label: knowledge,
+                    properties: {},
+                    chapterEstablished: chapter,
+                });
+            }
+            this.addEdge({
+                id: `edge-${character.name}-knows-${factId}`,
+                from: charNode.id,
+                to: factId,
+                type: 'knows',
+                properties: { since: chapter },
+            });
+        }
+    }
+    /**
+     * Add location to graph
+     */
+    addLocation(name, description, chapter) {
+        const locNode = {
+            id: `loc-${name}`,
+            type: 'location',
+            label: name,
+            properties: { description },
+            chapterEstablished: chapter,
+        };
+        this.addNode(locNode);
+    }
+    /**
+     * Add event to graph
+     */
+    addEvent(id, description, participants, chapter) {
+        const eventNode = {
+            id: `event-${id}`,
+            type: 'event',
+            label: description,
+            properties: { participants },
+            chapterEstablished: chapter,
+        };
+        this.addNode(eventNode);
+        // Connect participants to event
+        for (const participant of participants) {
+            const charId = `char-${participant}`;
+            if (this.nodes.has(charId)) {
+                this.addEdge({
+                    id: `edge-${participant}-participates-${id}`,
+                    from: charId,
+                    to: eventNode.id,
+                    type: 'participates_in',
+                    properties: { chapter },
+                });
+            }
+        }
+    }
+    /**
+     * Update character location
+     */
+    updateCharacterLocation(characterName, newLocation, chapter) {
+        const charId = `char-${characterName}`;
+        const charNode = this.nodes.get(charId);
+        if (charNode) {
+            // Update properties
+            charNode.properties.location = newLocation;
+            // Remove old location edges
+            const oldEdges = this.getEdgesFrom(charId).filter(e => e.type === 'located_at');
+            for (const edge of oldEdges) {
+                this.edges.delete(edge.id);
+                const adjSet = this.adjacencyList.get(edge.from);
+                if (adjSet) {
+                    adjSet.delete(edge.to);
+                }
+            }
+            // Add new location edge
+            this.addEdge({
+                id: `edge-${characterName}-loc-${chapter}`,
+                from: charId,
+                to: `loc-${newLocation}`,
+                type: 'located_at',
+                properties: { since: chapter },
+            });
+        }
+    }
+    /**
+     * Check for constraint violations
+     */
+    checkConstraints(currentChapter) {
+        const violations = [];
+        // Check location consistency
+        violations.push(...this.checkLocationConsistency(currentChapter));
+        // Check knowledge consistency
+        violations.push(...this.checkKnowledgeConsistency(currentChapter));
+        // Check timeline consistency
+        violations.push(...this.checkTimelineConsistency(currentChapter));
+        // Check logical consistency
+        violations.push(...this.checkLogicalConsistency(currentChapter));
+        return violations;
+    }
+    /**
+     * Check location consistency (no teleporting)
+     */
+    checkLocationConsistency(currentChapter) {
+        const violations = [];
+        for (const node of this.nodes.values()) {
+            if (node.type === 'character') {
+                const locationEdges = this.getEdgesFrom(node.id).filter(e => e.type === 'located_at');
+                // Sort by chapter
+                const sortedEdges = locationEdges.sort((a, b) => (a.properties.since || 0) - (b.properties.since || 0));
+                // Check for impossible movements (simplified)
+                // In a real implementation, you'd check travel times between locations
+                for (let i = 1; i < sortedEdges.length; i++) {
+                    const prevEdge = sortedEdges[i - 1];
+                    const currEdge = sortedEdges[i];
+                    const timeDiff = (currEdge.properties.since || 0) - (prevEdge.properties.since || 0);
+                    // If moved in same chapter, might be suspicious
+                    if (timeDiff === 0 && currEdge.properties.since === currentChapter) {
+                        violations.push({
+                            type: 'location',
+                            severity: 'warning',
+                            description: `${node.label} moved from ${prevEdge.to} to ${currEdge.to} instantly`,
+                            nodes: [node.id],
+                            suggestedFix: 'Add travel scene or justify rapid movement',
+                        });
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check knowledge consistency (no impossible knowledge)
+     */
+    checkKnowledgeConsistency(currentChapter) {
+        const violations = [];
+        for (const node of this.nodes.values()) {
+            if (node.type === 'character') {
+                const knowledgeEdges = this.getEdgesFrom(node.id).filter(e => e.type === 'knows');
+                for (const edge of knowledgeEdges) {
+                    const factNode = this.nodes.get(edge.to);
+                    if (factNode && factNode.chapterEstablished) {
+                        const knownSince = edge.properties.since || currentChapter;
+                        // Check if character knew fact before it was established
+                        if (knownSince < factNode.chapterEstablished) {
+                            violations.push({
+                                type: 'knowledge',
+                                severity: 'error',
+                                description: `${node.label} knows "${factNode.label}" before it happened (Ch ${knownSince} vs Ch ${factNode.chapterEstablished})`,
+                                nodes: [node.id, factNode.id],
+                                suggestedFix: 'Remove knowledge or adjust timeline',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check timeline consistency
+     */
+    checkTimelineConsistency(currentChapter) {
+        const violations = [];
+        // Check for events that reference future chapters
+        for (const node of this.nodes.values()) {
+            if (node.type === 'event' && node.chapterEstablished) {
+                if (node.chapterEstablished > currentChapter) {
+                    violations.push({
+                        type: 'timeline',
+                        severity: 'error',
+                        description: `Event "${node.label}" is set in future chapter ${node.chapterEstablished} but we're in chapter ${currentChapter}`,
+                        nodes: [node.id],
+                        suggestedFix: 'Adjust event chapter or remove reference',
+                    });
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Check logical consistency
+     */
+    checkLogicalConsistency(currentChapter) {
+        const violations = [];
+        // Check for characters participating in events when not present
+        for (const node of this.nodes.values()) {
+            if (node.type === 'event') {
+                const participants = node.properties.participants || [];
+                for (const participant of participants) {
+                    const charId = `char-${participant}`;
+                    const charNode = this.nodes.get(charId);
+                    if (charNode) {
+                        // Check if character was alive/present at event time
+                        if (charNode.chapterEstablished && node.chapterEstablished) {
+                            if (charNode.chapterEstablished > node.chapterEstablished) {
+                                violations.push({
+                                    type: 'logic',
+                                    severity: 'error',
+                                    description: `${participant} participates in event before they were introduced`,
+                                    nodes: [charId, node.id],
+                                    suggestedFix: 'Adjust character introduction or event timing',
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return violations;
+    }
+    /**
+     * Query what a character knows
+     */
+    getCharacterKnowledge(characterName) {
+        const charId = `char-${characterName}`;
+        const knowledgeEdges = this.getEdgesFrom(charId).filter(e => e.type === 'knows');
+        return knowledgeEdges
+            .map(edge => this.nodes.get(edge.to))
+            .filter((n) => n !== undefined && n.type === 'fact');
+    }
+    /**
+     * Query where a character is
+     */
+    getCharacterLocation(characterName) {
+        const charId = `char-${characterName}`;
+        const locationEdge = this.getEdgesFrom(charId).find(e => e.type === 'located_at');
+        if (locationEdge) {
+            const locNode = this.nodes.get(locationEdge.to);
+            return locNode?.label;
+        }
+        return undefined;
+    }
+    /**
+     * Serialize graph
+     */
+    serialize() {
+        return JSON.stringify({
+            nodes: Array.from(this.nodes.entries()),
+            edges: Array.from(this.edges.entries()),
+        });
+    }
+    /**
+     * Load graph from serialized data
+     */
+    load(data) {
+        const parsed = JSON.parse(data);
+        this.nodes = new Map(parsed.nodes);
+        this.edges = new Map(parsed.edges);
+        // Rebuild adjacency list
+        this.adjacencyList = new Map();
+        for (const [id, node] of this.nodes) {
+            this.adjacencyList.set(id, new Set());
+        }
+        for (const edge of this.edges.values()) {
+            const set = this.adjacencyList.get(edge.from);
+            if (set) {
+                set.add(edge.to);
+            }
+        }
+    }
+    /**
+     * Get graph statistics
+     */
+    getStats() {
+        const byType = {
+            character: 0,
+            location: 0,
+            fact: 0,
+            event: 0,
+            item: 0,
+        };
+        for (const node of this.nodes.values()) {
+            byType[node.type]++;
+        }
+        return {
+            nodes: this.nodes.size,
+            edges: this.edges.size,
+            byType,
+        };
+    }
+    /**
+     * Sanitize string for use as ID
+     */
+    sanitizeId(str) {
+        return str.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 50);
+    }
+}
+exports.ConstraintGraph = ConstraintGraph;
+function createConstraintGraph() {
+    return new ConstraintGraph();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constraintGraph.js","sourceRoot":"","sources":["../../src/constraints/constraintGraph.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CharacterState } from '../story/structuredState.js';\r\n\r\nexport type NodeType = 'character' | 'location' | 'fact' | 'event' | 'item';\r\n\r\nexport interface ConstraintNode {\r\n  id: string;\r\n  type: NodeType;\r\n  label: string;\r\n  properties: Record<string, any>;\r\n  chapterEstablished?: number;\r\n}\r\n\r\nexport interface ConstraintEdge {\r\n  id: string;\r\n  from: string;\r\n  to: string;\r\n  type: string;\r\n  properties: Record<string, any>;\r\n}\r\n\r\nexport interface ConstraintViolation {\r\n  type: 'canon' | 'location' | 'knowledge' | 'timeline' | 'logic';\r\n  severity: 'error' | 'warning';\r\n  description: string;\r\n  nodes: string[];\r\n  suggestedFix?: string;\r\n}\r\n\r\nexport class ConstraintGraph {\r\n  private nodes: Map<string, ConstraintNode> = new Map();\r\n  private edges: Map<string, ConstraintEdge> = new Map();\r\n  private adjacencyList: Map<string, Set<string>> = new Map();\r\n  \r\n  /**\r\n   * Add a node to the graph\r\n   */\r\n  addNode(node: ConstraintNode): void {\r\n    this.nodes.set(node.id, node);\r\n    if (!this.adjacencyList.has(node.id)) {\r\n      this.adjacencyList.set(node.id, new Set());\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Add an edge between nodes\r\n   */\r\n  addEdge(edge: ConstraintEdge): void {\r\n    // Validate nodes exist\r\n    if (!this.nodes.has(edge.from) || !this.nodes.has(edge.to)) {\r\n      throw new Error(`Cannot add edge: node not found (${edge.from} -> ${edge.to})`);\r\n    }\r\n    \r\n    this.edges.set(edge.id, edge);\r\n    \r\n    // Update adjacency list\r\n    const fromSet = this.adjacencyList.get(edge.from);\r\n    if (fromSet) {\r\n      fromSet.add(edge.to);\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Get a node by ID\r\n   */\r\n  getNode(id: string): ConstraintNode | undefined {\r\n    return this.nodes.get(id);\r\n  }\r\n  \r\n  /**\r\n   * Get all edges from a node\r\n   */\r\n  getEdgesFrom(nodeId: string): ConstraintEdge[] {\r\n    return Array.from(this.edges.values()).filter(e => e.from === nodeId);\r\n  }\r\n  \r\n  /**\r\n   * Get all edges to a node\r\n   */\r\n  getEdgesTo(nodeId: string): ConstraintEdge[] {\r\n    return Array.from(this.edges.values()).filter(e => e.to === nodeId);\r\n  }\r\n  \r\n  /**\r\n   * Get neighbors of a node\r\n   */\r\n  getNeighbors(nodeId: string): ConstraintNode[] {\r\n    const neighborIds = this.adjacencyList.get(nodeId);\r\n    if (!neighborIds) return [];\r\n    \r\n    return Array.from(neighborIds)\r\n      .map(id => this.nodes.get(id))\r\n      .filter((n): n is ConstraintNode => n !== undefined);\r\n  }\r\n  \r\n  /**\r\n   * Add character to graph\r\n   */\r\n  addCharacter(character: CharacterState, chapter: number): void {\r\n    const charNode: ConstraintNode = {\r\n      id: `char-${character.name}`,\r\n      type: 'character',\r\n      label: character.name,\r\n      properties: {\r\n        emotionalState: character.emotionalState,\r\n        location: character.location,\r\n        goals: character.goals,\r\n      },\r\n      chapterEstablished: chapter,\r\n    };\r\n    \r\n    this.addNode(charNode);\r\n    \r\n    // Add location edge\r\n    this.addEdge({\r\n      id: `edge-${character.name}-loc`,\r\n      from: charNode.id,\r\n      to: `loc-${character.location}`,\r\n      type: 'located_at',\r\n      properties: { since: chapter },\r\n    });\r\n    \r\n    // Add knowledge nodes and edges\r\n    for (const knowledge of character.knowledge) {\r\n      const factId = `fact-${this.sanitizeId(knowledge)}`;\r\n      if (!this.nodes.has(factId)) {\r\n        this.addNode({\r\n          id: factId,\r\n          type: 'fact',\r\n          label: knowledge,\r\n          properties: {},\r\n          chapterEstablished: chapter,\r\n        });\r\n      }\r\n      \r\n      this.addEdge({\r\n        id: `edge-${character.name}-knows-${factId}`,\r\n        from: charNode.id,\r\n        to: factId,\r\n        type: 'knows',\r\n        properties: { since: chapter },\r\n      });\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Add location to graph\r\n   */\r\n  addLocation(name: string, description: string, chapter: number): void {\r\n    const locNode: ConstraintNode = {\r\n      id: `loc-${name}`,\r\n      type: 'location',\r\n      label: name,\r\n      properties: { description },\r\n      chapterEstablished: chapter,\r\n    };\r\n    \r\n    this.addNode(locNode);\r\n  }\r\n  \r\n  /**\r\n   * Add event to graph\r\n   */\r\n  addEvent(\r\n    id: string,\r\n    description: string,\r\n    participants: string[],\r\n    chapter: number\r\n  ): void {\r\n    const eventNode: ConstraintNode = {\r\n      id: `event-${id}`,\r\n      type: 'event',\r\n      label: description,\r\n      properties: { participants },\r\n      chapterEstablished: chapter,\r\n    };\r\n    \r\n    this.addNode(eventNode);\r\n    \r\n    // Connect participants to event\r\n    for (const participant of participants) {\r\n      const charId = `char-${participant}`;\r\n      if (this.nodes.has(charId)) {\r\n        this.addEdge({\r\n          id: `edge-${participant}-participates-${id}`,\r\n          from: charId,\r\n          to: eventNode.id,\r\n          type: 'participates_in',\r\n          properties: { chapter },\r\n        });\r\n      }\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Update character location\r\n   */\r\n  updateCharacterLocation(characterName: string, newLocation: string, chapter: number): void {\r\n    const charId = `char-${characterName}`;\r\n    const charNode = this.nodes.get(charId);\r\n    \r\n    if (charNode) {\r\n      // Update properties\r\n      charNode.properties.location = newLocation;\r\n      \r\n      // Remove old location edges\r\n      const oldEdges = this.getEdgesFrom(charId).filter(e => e.type === 'located_at');\r\n      for (const edge of oldEdges) {\r\n        this.edges.delete(edge.id);\r\n        const adjSet = this.adjacencyList.get(edge.from);\r\n        if (adjSet) {\r\n          adjSet.delete(edge.to);\r\n        }\r\n      }\r\n      \r\n      // Add new location edge\r\n      this.addEdge({\r\n        id: `edge-${characterName}-loc-${chapter}`,\r\n        from: charId,\r\n        to: `loc-${newLocation}`,\r\n        type: 'located_at',\r\n        properties: { since: chapter },\r\n      });\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Check for constraint violations\r\n   */\r\n  checkConstraints(currentChapter: number): ConstraintViolation[] {\r\n    const violations: ConstraintViolation[] = [];\r\n    \r\n    // Check location consistency\r\n    violations.push(...this.checkLocationConsistency(currentChapter));\r\n    \r\n    // Check knowledge consistency\r\n    violations.push(...this.checkKnowledgeConsistency(currentChapter));\r\n    \r\n    // Check timeline consistency\r\n    violations.push(...this.checkTimelineConsistency(currentChapter));\r\n    \r\n    // Check logical consistency\r\n    violations.push(...this.checkLogicalConsistency(currentChapter));\r\n    \r\n    return violations;\r\n  }\r\n  \r\n  /**\r\n   * Check location consistency (no teleporting)\r\n   */\r\n  private checkLocationConsistency(currentChapter: number): ConstraintViolation[] {\r\n    const violations: ConstraintViolation[] = [];\r\n    \r\n    for (const node of this.nodes.values()) {\r\n      if (node.type === 'character') {\r\n        const locationEdges = this.getEdgesFrom(node.id).filter(e => e.type === 'located_at');\r\n        \r\n        // Sort by chapter\r\n        const sortedEdges = locationEdges.sort((a, b) => \r\n          (a.properties.since || 0) - (b.properties.since || 0)\r\n        );\r\n        \r\n        // Check for impossible movements (simplified)\r\n        // In a real implementation, you'd check travel times between locations\r\n        for (let i = 1; i < sortedEdges.length; i++) {\r\n          const prevEdge = sortedEdges[i - 1];\r\n          const currEdge = sortedEdges[i];\r\n          const timeDiff = (currEdge.properties.since || 0) - (prevEdge.properties.since || 0);\r\n          \r\n          // If moved in same chapter, might be suspicious\r\n          if (timeDiff === 0 && currEdge.properties.since === currentChapter) {\r\n            violations.push({\r\n              type: 'location',\r\n              severity: 'warning',\r\n              description: `${node.label} moved from ${prevEdge.to} to ${currEdge.to} instantly`,\r\n              nodes: [node.id],\r\n              suggestedFix: 'Add travel scene or justify rapid movement',\r\n            });\r\n          }\r\n        }\r\n      }\r\n    }\r\n    \r\n    return violations;\r\n  }\r\n  \r\n  /**\r\n   * Check knowledge consistency (no impossible knowledge)\r\n   */\r\n  private checkKnowledgeConsistency(currentChapter: number): ConstraintViolation[] {\r\n    const violations: ConstraintViolation[] = [];\r\n    \r\n    for (const node of this.nodes.values()) {\r\n      if (node.type === 'character') {\r\n        const knowledgeEdges = this.getEdgesFrom(node.id).filter(e => e.type === 'knows');\r\n        \r\n        for (const edge of knowledgeEdges) {\r\n          const factNode = this.nodes.get(edge.to);\r\n          if (factNode && factNode.chapterEstablished) {\r\n            const knownSince = edge.properties.since || currentChapter;\r\n            \r\n            // Check if character knew fact before it was established\r\n            if (knownSince < factNode.chapterEstablished) {\r\n              violations.push({\r\n                type: 'knowledge',\r\n                severity: 'error',\r\n                description: `${node.label} knows \"${factNode.label}\" before it happened (Ch ${knownSince} vs Ch ${factNode.chapterEstablished})`,\r\n                nodes: [node.id, factNode.id],\r\n                suggestedFix: 'Remove knowledge or adjust timeline',\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    \r\n    return violations;\r\n  }\r\n  \r\n  /**\r\n   * Check timeline consistency\r\n   */\r\n  private checkTimelineConsistency(currentChapter: number): ConstraintViolation[] {\r\n    const violations: ConstraintViolation[] = [];\r\n    \r\n    // Check for events that reference future chapters\r\n    for (const node of this.nodes.values()) {\r\n      if (node.type === 'event' && node.chapterEstablished) {\r\n        if (node.chapterEstablished > currentChapter) {\r\n          violations.push({\r\n            type: 'timeline',\r\n            severity: 'error',\r\n            description: `Event \"${node.label}\" is set in future chapter ${node.chapterEstablished} but we're in chapter ${currentChapter}`,\r\n            nodes: [node.id],\r\n            suggestedFix: 'Adjust event chapter or remove reference',\r\n          });\r\n        }\r\n      }\r\n    }\r\n    \r\n    return violations;\r\n  }\r\n  \r\n  /**\r\n   * Check logical consistency\r\n   */\r\n  private checkLogicalConsistency(currentChapter: number): ConstraintViolation[] {\r\n    const violations: ConstraintViolation[] = [];\r\n    \r\n    // Check for characters participating in events when not present\r\n    for (const node of this.nodes.values()) {\r\n      if (node.type === 'event') {\r\n        const participants = node.properties.participants || [];\r\n        \r\n        for (const participant of participants) {\r\n          const charId = `char-${participant}`;\r\n          const charNode = this.nodes.get(charId);\r\n          \r\n          if (charNode) {\r\n            // Check if character was alive/present at event time\r\n            if (charNode.chapterEstablished && node.chapterEstablished) {\r\n              if (charNode.chapterEstablished > node.chapterEstablished) {\r\n                violations.push({\r\n                  type: 'logic',\r\n                  severity: 'error',\r\n                  description: `${participant} participates in event before they were introduced`,\r\n                  nodes: [charId, node.id],\r\n                  suggestedFix: 'Adjust character introduction or event timing',\r\n                });\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    \r\n    return violations;\r\n  }\r\n  \r\n  /**\r\n   * Query what a character knows\r\n   */\r\n  getCharacterKnowledge(characterName: string): ConstraintNode[] {\r\n    const charId = `char-${characterName}`;\r\n    const knowledgeEdges = this.getEdgesFrom(charId).filter(e => e.type === 'knows');\r\n    \r\n    return knowledgeEdges\r\n      .map(edge => this.nodes.get(edge.to))\r\n      .filter((n): n is ConstraintNode => n !== undefined && n.type === 'fact');\r\n  }\r\n  \r\n  /**\r\n   * Query where a character is\r\n   */\r\n  getCharacterLocation(characterName: string): string | undefined {\r\n    const charId = `char-${characterName}`;\r\n    const locationEdge = this.getEdgesFrom(charId).find(e => e.type === 'located_at');\r\n    \r\n    if (locationEdge) {\r\n      const locNode = this.nodes.get(locationEdge.to);\r\n      return locNode?.label;\r\n    }\r\n    \r\n    return undefined;\r\n  }\r\n  \r\n  /**\r\n   * Serialize graph\r\n   */\r\n  serialize(): string {\r\n    return JSON.stringify({\r\n      nodes: Array.from(this.nodes.entries()),\r\n      edges: Array.from(this.edges.entries()),\r\n    });\r\n  }\r\n  \r\n  /**\r\n   * Load graph from serialized data\r\n   */\r\n  load(data: string): void {\r\n    const parsed = JSON.parse(data);\r\n    this.nodes = new Map(parsed.nodes);\r\n    this.edges = new Map(parsed.edges);\r\n    \r\n    // Rebuild adjacency list\r\n    this.adjacencyList = new Map();\r\n    for (const [id, node] of this.nodes) {\r\n      this.adjacencyList.set(id, new Set());\r\n    }\r\n    for (const edge of this.edges.values()) {\r\n      const set = this.adjacencyList.get(edge.from);\r\n      if (set) {\r\n        set.add(edge.to);\r\n      }\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Get graph statistics\r\n   */\r\n  getStats(): { nodes: number; edges: number; byType: Record<NodeType, number> } {\r\n    const byType: Record<NodeType, number> = {\r\n      character: 0,\r\n      location: 0,\r\n      fact: 0,\r\n      event: 0,\r\n      item: 0,\r\n    };\r\n    \r\n    for (const node of this.nodes.values()) {\r\n      byType[node.type]++;\r\n    }\r\n    \r\n    return {\r\n      nodes: this.nodes.size,\r\n      edges: this.edges.size,\r\n      byType,\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Sanitize string for use as ID\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 function createConstraintGraph(): ConstraintGraph {\r\n  return new ConstraintGraph();\r\n}\r\n"]}

package/dist/constraints/validator.d.ts

@@ -0,0 +1,58 @@
+import type { Chapter, StoryBible } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+import type { CanonStore } from '../memory/canonStore.js';
+import { ConstraintGraph, type ConstraintViolation } from './constraintGraph.js';
+export interface ValidationResult {
+    valid: boolean;
+    violations: ConstraintViolation[];
+    summary: string;
+}
+export interface ChapterValidationContext {
+    chapter: Chapter;
+    bible: StoryBible;
+    structuredState: StoryStructuredState;
+    canon: CanonStore;
+    previousChapters: Chapter[];
+    constraintGraph: ConstraintGraph;
+}
+export declare class Validator {
+    private constraintGraph;
+    constructor(constraintGraph?: ConstraintGraph);
+    /**
+     * Validate a chapter using both graph-based and LLM-based checks
+     */
+    validateChapter(context: ChapterValidationContext): Promise<ValidationResult>;
+    /**
+     * LLM-based validation
+     */
+    private llmValidate;
+    /**
+     * Quick validation without LLM (for testing/fallback)
+     */
+    quickValidate(context: ChapterValidationContext): ValidationResult;
+    /**
+     * Basic canon check (keyword matching)
+     */
+    private checkCanonBasic;
+    /**
+     * Format canon for prompt
+     */
+    private formatCanon;
+    /**
+     * Format characters for prompt
+     */
+    private formatCharacters;
+    /**
+     * Format plot threads for prompt
+     */
+    private formatPlotThreads;
+    /**
+     * Format validation result for display
+     */
+    formatResult(result: ValidationResult): string;
+    /**
+     * Get the constraint graph
+     */
+    getConstraintGraph(): ConstraintGraph;
+}
+export declare const validator: Validator;