@sharpee/parser-en-us 0.9.60-beta

package/dist/english-parser.js

@@ -0,0 +1,1268 @@
+"use strict";
+/**
+ * English Parser Implementation
+ *
+ * This parser handles English-specific grammar patterns and preserves all information
+ * in rich structured commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnglishParser = void 0;
+const if_domain_1 = require("@sharpee/if-domain");
+const world_model_1 = require("@sharpee/world-model");
+const english_grammar_engine_1 = require("./english-grammar-engine");
+const grammar_1 = require("./grammar");
+const direction_mappings_1 = require("./direction-mappings");
+const parse_failure_1 = require("./parse-failure");
+const pronoun_context_1 = require("./pronoun-context");
+/**
+ * Default parser options
+ */
+const DEFAULT_OPTIONS = {
+    allowPartial: true,
+    expandAbbreviations: true,
+    ignoreArticles: false, // We preserve everything in the English parser
+    minConfidence: 0.1
+};
+/**
+ * Map vocabulary part of speech to world model part of speech
+ */
+function mapPartOfSpeech(vocabPos) {
+    switch (vocabPos) {
+        case if_domain_1.PartOfSpeech.VERB:
+            return world_model_1.PartOfSpeech.VERB;
+        case if_domain_1.PartOfSpeech.NOUN:
+            return world_model_1.PartOfSpeech.NOUN;
+        case if_domain_1.PartOfSpeech.ADJECTIVE:
+            return world_model_1.PartOfSpeech.ADJECTIVE;
+        case if_domain_1.PartOfSpeech.ARTICLE:
+            return world_model_1.PartOfSpeech.ARTICLE;
+        case if_domain_1.PartOfSpeech.PREPOSITION:
+            return world_model_1.PartOfSpeech.PREPOSITION;
+        case if_domain_1.PartOfSpeech.PRONOUN:
+            return world_model_1.PartOfSpeech.PRONOUN;
+        // Note: stdlib doesn't have DETERMINER, but we map special words to DETERMINER
+        case if_domain_1.PartOfSpeech.SPECIAL:
+            // Special words could be determiners
+            return world_model_1.PartOfSpeech.DETERMINER;
+        default:
+            return world_model_1.PartOfSpeech.UNKNOWN;
+    }
+}
+/**
+ * English parser with rich information preservation
+ */
+class EnglishParser {
+    options;
+    language;
+    onDebugEvent;
+    platformEventEmitter;
+    grammarEngine;
+    worldContext = null;
+    /** Pronoun context manager for "it", "them", "him", "her" resolution (ADR-089) */
+    pronounContext;
+    constructor(language, options = {}) {
+        this.language = language;
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+        // Initialize grammar engine
+        this.grammarEngine = new english_grammar_engine_1.EnglishGrammarEngine();
+        const grammar = this.grammarEngine.createBuilder();
+        (0, grammar_1.defineGrammar)(grammar);
+        // Initialize pronoun context (ADR-089)
+        this.pronounContext = new pronoun_context_1.PronounContextManager();
+        (0, pronoun_context_1.setPronounContextManager)(this.pronounContext);
+        this.initializeVocabulary();
+    }
+    /**
+     * Initialize vocabulary from language provider
+     */
+    initializeVocabulary() {
+        // Clear any existing vocabulary
+        if_domain_1.vocabularyRegistry.clear();
+        // Register verbs (adapting from language provider format)
+        const verbs = (0, if_domain_1.adaptVerbVocabulary)(this.language);
+        if_domain_1.vocabularyRegistry.registerVerbs(verbs);
+        // Register directions (adapting from language provider format)
+        const directions = (0, if_domain_1.adaptDirectionVocabulary)(this.language);
+        if_domain_1.vocabularyRegistry.registerDirections(directions);
+        // Register special vocabulary (adapting from language provider format)
+        const special = (0, if_domain_1.adaptSpecialVocabulary)(this.language);
+        if_domain_1.vocabularyRegistry.registerSpecial(special);
+        // Register prepositions
+        const prepositions = this.language.getPrepositions();
+        if_domain_1.vocabularyRegistry.registerPrepositions(prepositions);
+        // Register determiners
+        const determiners = this.language.getDeterminers();
+        if_domain_1.vocabularyRegistry.registerDeterminers(determiners);
+        // Register conjunctions
+        const conjunctions = this.language.getConjunctions();
+        if_domain_1.vocabularyRegistry.registerConjunctions(conjunctions);
+        // Register numbers
+        const numbers = this.language.getNumbers();
+        if_domain_1.vocabularyRegistry.registerNumbers(numbers);
+    }
+    /**
+     * Set debug event callback
+     */
+    setDebugCallback(callback) {
+        this.onDebugEvent = callback;
+    }
+    /**
+     * Set platform event emitter for parser debugging
+     */
+    setPlatformEventEmitter(emitter) {
+        this.platformEventEmitter = emitter;
+    }
+    /**
+     * Set the world context for scope constraint evaluation
+     */
+    setWorldContext(world, actorId, currentLocation) {
+        this.worldContext = { world, actorId, currentLocation };
+    }
+    /**
+     * Emit a platform debug event
+     */
+    emitPlatformEvent(type, data) {
+        if (this.platformEventEmitter) {
+            this.platformEventEmitter({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                type: `platform.parser.${type}`,
+                entities: {},
+                payload: {
+                    subsystem: 'parser',
+                    ...data
+                },
+                tags: ['platform', 'parser', 'debug'],
+                priority: 0,
+                narrate: false
+            });
+        }
+    }
+    /**
+     * Register additional verbs after parser creation
+     * Used for story-specific vocabulary
+     */
+    registerVerbs(verbs) {
+        // Register with vocabulary registry
+        if_domain_1.vocabularyRegistry.registerDynamicVerbs(verbs, 'story');
+    }
+    /**
+     * Register additional vocabulary entries
+     * More generic than registerVerbs - can handle any part of speech
+     */
+    registerVocabulary(entries) {
+        // Group by part of speech and register appropriately
+        const verbs = [];
+        for (const entry of entries) {
+            if (entry.partOfSpeech === if_domain_1.PartOfSpeech.VERB) {
+                // Find or create verb definition for this action
+                let verbDef = verbs.find(v => v.actionId === entry.mapsTo);
+                if (!verbDef) {
+                    verbDef = {
+                        actionId: entry.mapsTo,
+                        verbs: [],
+                        pattern: entry.metadata?.pattern,
+                        prepositions: entry.metadata?.prepositions
+                    };
+                    verbs.push(verbDef);
+                }
+                verbDef.verbs.push(entry.word);
+            }
+            // Future: handle other parts of speech
+        }
+        if (verbs.length > 0) {
+            this.registerVerbs(verbs);
+        }
+    }
+    /**
+     * Parse input text into structured command with rich information
+     */
+    parse(input) {
+        // Emit parse start event
+        this.emitPlatformEvent('parse_start', { input });
+        // Tokenize with full position tracking
+        const tokens = this.tokenizeRich(input);
+        // Emit tokenize platform event
+        this.emitPlatformEvent('tokenize_complete', {
+            input,
+            tokens: tokens.map(t => ({
+                word: t.word,
+                normalized: t.normalized,
+                partOfSpeech: t.partOfSpeech,
+                candidateCount: t.candidates.length
+            }))
+        });
+        // Emit tokenize debug event
+        if (this.onDebugEvent) {
+            // Find unknown words
+            const unknownWords = tokens
+                .filter(t => t.partOfSpeech.includes(world_model_1.PartOfSpeech.UNKNOWN) || t.candidates.length === 0)
+                .map(t => t.word);
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'tokenize',
+                data: {
+                    input,
+                    tokens: tokens.map(t => ({
+                        word: t.word,
+                        normalized: t.normalized,
+                        position: t.position,
+                        length: t.length,
+                        partOfSpeech: t.partOfSpeech,
+                        candidateCount: t.candidates.length
+                    })),
+                    unknownWords
+                }
+            });
+        }
+        // Try to find command structure
+        const candidates = this.findCommandStructures(tokens, input);
+        // Emit pattern matching platform event
+        this.emitPlatformEvent('pattern_matching_complete', {
+            input,
+            candidateCount: candidates.length,
+            patterns: candidates.map(c => ({
+                pattern: c.pattern,
+                action: c.action,
+                confidence: c.confidence
+            }))
+        });
+        // Emit pattern match debug event
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'pattern_match',
+                data: {
+                    input,
+                    patternsAttempted: candidates.map(c => ({
+                        name: c.pattern,
+                        matched: true,
+                        confidence: c.confidence
+                    })),
+                    totalCandidates: candidates.length
+                }
+            });
+        }
+        if (candidates.length === 0) {
+            // Analyze failures to determine the best error message
+            const failures = this.grammarEngine.getLastFailures();
+            const hadVerb = tokens.some(t => t.partOfSpeech.includes(world_model_1.PartOfSpeech.VERB));
+            const errorAnalysis = (0, parse_failure_1.analyzeBestFailure)(failures, input, hadVerb);
+            // Emit parse error platform event
+            this.emitPlatformEvent('parse_failed', {
+                input,
+                reason: 'no_matching_patterns',
+                tokenCount: tokens.length,
+                hadVerb,
+                errorCode: errorAnalysis.code,
+                errorContext: errorAnalysis.context
+            });
+            // Emit parse error debug event
+            if (this.onDebugEvent) {
+                this.onDebugEvent({
+                    id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: Date.now(),
+                    subsystem: 'parser',
+                    type: 'parse_error',
+                    data: {
+                        input,
+                        errorType: errorAnalysis.code,
+                        errorDetails: {
+                            messageId: errorAnalysis.messageId,
+                            context: errorAnalysis.context,
+                            hadTokens: tokens.length > 0,
+                            hadVerb,
+                            failureCount: failures.length
+                        }
+                    }
+                });
+            }
+            // Build the detailed error message
+            const error = this.buildParseError(input, errorAnalysis);
+            return {
+                success: false,
+                error
+            };
+        }
+        // Sort by confidence and take the best
+        candidates.sort((a, b) => b.confidence - a.confidence);
+        const best = candidates[0];
+        // Emit candidate selection debug event
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'candidate_selection',
+                data: {
+                    input,
+                    candidates: candidates.map((c, i) => ({
+                        action: c.action,
+                        pattern: c.pattern,
+                        confidence: c.confidence,
+                        selected: i === 0
+                    })),
+                    selectionReason: candidates.length === 1 ? 'only_candidate' : 'highest_confidence'
+                }
+            });
+        }
+        // Build the ParsedCommand
+        const parsed = {
+            rawInput: input,
+            tokens: best.tokens,
+            structure: {
+                verb: best.verb,
+                directObject: best.directObject,
+                preposition: best.preposition,
+                indirectObject: best.indirectObject
+            },
+            pattern: best.pattern,
+            confidence: best.confidence,
+            action: best.action,
+            // ADR-080 additions
+            textSlots: best.textSlots,
+            instrument: best.instrument,
+            excluded: best.excluded,
+            // ADR-082 additions
+            vocabularySlots: best.vocabularySlots,
+            manner: best.manner
+        };
+        // Add extras if present
+        if (best.direction) {
+            // Convert direction string to Direction constant
+            const directionConstant = (0, direction_mappings_1.parseDirection)(best.direction);
+            parsed.extras = {
+                direction: directionConstant || best.direction
+            };
+        }
+        else if (best.extras) {
+            // Check if extras contains a direction and convert it
+            const extras = { ...best.extras };
+            if (extras.direction && typeof extras.direction === 'string') {
+                const directionConstant = (0, direction_mappings_1.parseDirection)(extras.direction);
+                if (directionConstant) {
+                    extras.direction = directionConstant;
+                }
+            }
+            parsed.extras = extras;
+        }
+        // Emit parse success platform event
+        this.emitPlatformEvent('parse_success', {
+            input,
+            action: parsed.action,
+            pattern: parsed.pattern,
+            confidence: parsed.confidence,
+            structure: {
+                verb: parsed.structure.verb?.text,
+                directObject: parsed.structure.directObject?.text,
+                preposition: parsed.structure.preposition?.text,
+                indirectObject: parsed.structure.indirectObject?.text
+            }
+        });
+        return {
+            success: true,
+            value: parsed
+        };
+    }
+    /**
+     * Parse input that may contain multiple commands separated by periods or commas.
+     * Returns an array of parsed commands (or errors).
+     *
+     * Period chaining:
+     * - "take sword. go north." → [take sword, go north]
+     *
+     * Comma chaining (only when verb detected after comma):
+     * - "take sword, drop it" → [take sword, drop it] (verb after comma)
+     * - "take knife, lamp" → single command with list (no verb after comma)
+     *
+     * Examples:
+     * - "take sword. go north." → [take sword, go north]
+     * - "take sword" → [take sword]
+     * - "take sword. invalid. go north" → [take sword, error, go north]
+     */
+    parseChain(input) {
+        // First split on periods
+        const periodSegments = this.splitOnPeriods(input);
+        // Then handle comma disambiguation within each segment
+        const allSegments = [];
+        for (const segment of periodSegments) {
+            const commaSegments = this.splitOnCommasIfChain(segment);
+            allSegments.push(...commaSegments);
+        }
+        // Parse each segment
+        return allSegments.map(segment => this.parse(segment));
+    }
+    /**
+     * Split a segment on commas only if a verb is detected after the comma.
+     * "take knife, drop lamp" → ["take knife", "drop lamp"] (verb after comma)
+     * "take knife, lamp" → ["take knife, lamp"] (no verb, treat as list)
+     */
+    splitOnCommasIfChain(input) {
+        // Replace quoted strings with placeholders to protect them
+        const placeholders = new Map();
+        let processedInput = input;
+        let placeholderIndex = 0;
+        // Handle double quotes
+        processedInput = processedInput.replace(/"[^"]*"/g, (match) => {
+            const placeholder = `__COMMA_QUOTE_${placeholderIndex++}__`;
+            placeholders.set(placeholder, match);
+            return placeholder;
+        });
+        // Handle single quotes
+        processedInput = processedInput.replace(/'[^']*'/g, (match) => {
+            const placeholder = `__COMMA_QUOTE_${placeholderIndex++}__`;
+            placeholders.set(placeholder, match);
+            return placeholder;
+        });
+        // Check for commas
+        const commaIndex = processedInput.indexOf(',');
+        if (commaIndex === -1) {
+            return [input]; // No commas, return as-is
+        }
+        // Check if word after comma is a verb
+        const afterComma = processedInput.slice(commaIndex + 1).trim();
+        const firstWordMatch = afterComma.match(/^(\w+)/);
+        if (!firstWordMatch) {
+            return [input]; // No word after comma, return as-is
+        }
+        const firstWord = firstWordMatch[1].toLowerCase();
+        // Check if it's a known verb
+        const isVerb = if_domain_1.vocabularyRegistry.hasWord(firstWord, if_domain_1.PartOfSpeech.VERB);
+        if (isVerb) {
+            // It's a verb - split into separate commands
+            const parts = processedInput.split(',');
+            const segments = [];
+            for (const part of parts) {
+                let restored = part;
+                for (const [placeholder, original] of placeholders) {
+                    restored = restored.replace(placeholder, original);
+                }
+                const trimmed = restored.trim();
+                if (trimmed.length > 0) {
+                    segments.push(trimmed);
+                }
+            }
+            return segments;
+        }
+        // Not a verb after comma - return as single segment (list)
+        return [input];
+    }
+    /**
+     * Split input on periods, preserving quoted strings.
+     * Handles edge cases like trailing periods and empty segments.
+     */
+    splitOnPeriods(input) {
+        // Replace quoted strings with placeholders
+        const placeholders = new Map();
+        let processedInput = input;
+        let placeholderIndex = 0;
+        // Handle double quotes
+        processedInput = processedInput.replace(/"[^"]*"/g, (match) => {
+            const placeholder = `__PERIOD_QUOTE_${placeholderIndex++}__`;
+            placeholders.set(placeholder, match);
+            return placeholder;
+        });
+        // Handle single quotes
+        processedInput = processedInput.replace(/'[^']*'/g, (match) => {
+            const placeholder = `__PERIOD_QUOTE_${placeholderIndex++}__`;
+            placeholders.set(placeholder, match);
+            return placeholder;
+        });
+        // Split on periods
+        const rawSegments = processedInput.split('.');
+        // Restore placeholders and clean up segments
+        const segments = [];
+        for (const segment of rawSegments) {
+            let restored = segment;
+            for (const [placeholder, original] of placeholders) {
+                restored = restored.replace(placeholder, original);
+            }
+            const trimmed = restored.trim();
+            if (trimmed.length > 0) {
+                segments.push(trimmed);
+            }
+        }
+        return segments;
+    }
+    /**
+     * Tokenize input with rich information preservation
+     */
+    tokenizeRich(input) {
+        const tokens = [];
+        let position = 0;
+        // First extract quoted strings and replace them with placeholders
+        const quotedStrings = [];
+        let processedInput = input;
+        // Handle double quotes
+        const doubleQuoteRegex = /"([^"]*)"/g;
+        let match;
+        let quoteIndex = 0;
+        while ((match = doubleQuoteRegex.exec(input)) !== null) {
+            const placeholder = `__QUOTE_${quoteIndex}__`;
+            const content = match[1];
+            const quotePosition = match.index;
+            quotedStrings.push({ placeholder, content, position: quotePosition });
+            processedInput = processedInput.replace(match[0], placeholder);
+            quoteIndex++;
+        }
+        // Now tokenize the processed input
+        const words = processedInput.trim().split(/(\s+)/); // Keep whitespace for position tracking
+        for (const segment of words) {
+            // Skip pure whitespace segments
+            if (/^\s+$/.test(segment)) {
+                position += segment.length;
+                continue;
+            }
+            // Check if this is a quoted string placeholder
+            const quotedString = quotedStrings.find(qs => qs.placeholder === segment);
+            if (quotedString) {
+                // Create a token for the quoted string
+                tokens.push({
+                    word: `"${quotedString.content}"`,
+                    normalized: quotedString.content.toLowerCase(),
+                    position,
+                    length: quotedString.content.length + 2, // Include quotes
+                    partOfSpeech: [world_model_1.PartOfSpeech.NOUN], // Treat quoted strings as nouns
+                    candidates: [{
+                            id: 'quoted_string',
+                            type: 'noun',
+                            confidence: 1.0
+                        }]
+                });
+                position += segment.length;
+                continue;
+            }
+            const normalized = segment.toLowerCase();
+            const vocabCandidates = this.getTokenCandidates(normalized);
+            // Convert to rich token candidates
+            const candidates = vocabCandidates.map(vc => ({
+                id: vc.mapsTo,
+                type: vc.partOfSpeech,
+                confidence: vc.priority || 1.0
+            }));
+            // Determine parts of speech
+            const partsOfSpeech = Array.from(new Set(vocabCandidates.map(vc => mapPartOfSpeech(vc.partOfSpeech))));
+            // If no vocabulary matches, mark as unknown
+            if (partsOfSpeech.length === 0) {
+                partsOfSpeech.push(world_model_1.PartOfSpeech.UNKNOWN);
+            }
+            tokens.push({
+                word: segment,
+                normalized,
+                position,
+                length: segment.length,
+                partOfSpeech: partsOfSpeech,
+                candidates
+            });
+            position += segment.length;
+        }
+        return tokens;
+    }
+    /**
+     * Find possible command structures in the tokens
+     */
+    findCommandStructures(tokens, input) {
+        // Create grammar context with world model if available
+        const context = {
+            world: this.worldContext?.world || null,
+            actorId: this.worldContext?.actorId || 'player',
+            currentLocation: this.worldContext?.currentLocation || 'current',
+            slots: new Map()
+        };
+        // Convert tokens to internal format for grammar engine
+        const internalTokens = tokens.map(t => ({
+            word: t.word,
+            normalized: t.normalized,
+            position: t.position,
+            candidates: t.candidates.map((c) => ({
+                partOfSpeech: c.type,
+                mapsTo: c.id,
+                priority: c.confidence || 0
+            }))
+        }));
+        // Use grammar engine to find matches
+        const matches = this.grammarEngine.findMatches(internalTokens, context);
+        // Convert grammar matches to RichCandidates
+        const candidates = [];
+        for (const match of matches) {
+            const candidate = this.convertGrammarMatch(match, tokens);
+            if (candidate) {
+                candidates.push(candidate);
+            }
+            else if (input.includes('throw')) {
+                console.log('Failed to convert match:', match.rule.pattern);
+            }
+        }
+        return candidates;
+    }
+    /**
+     * Convert a grammar match to a RichCandidate
+     */
+    convertGrammarMatch(match, tokens) {
+        const rule = match.rule;
+        // Extract verb tokens from the beginning of the match
+        const verbTokenIndices = [];
+        let verbEndIndex = 0;
+        // Find verb tokens at the start
+        for (let i = 0; i < tokens.length; i++) {
+            if (tokens[i].partOfSpeech.includes(world_model_1.PartOfSpeech.VERB)) {
+                verbTokenIndices.push(i);
+                verbEndIndex = i + 1;
+            }
+            else {
+                break;
+            }
+        }
+        // Build verb phrase
+        const verbPhrase = {
+            tokens: verbTokenIndices,
+            text: verbTokenIndices.map(i => tokens[i].word).join(' '),
+            head: verbTokenIndices.length > 0 ? tokens[verbTokenIndices[0]].normalized : ''
+        };
+        // For complex patterns with multiple slots and prepositions,
+        // we need to analyze the pattern structure
+        const slotEntries = Array.from(match.slots.entries());
+        // Sort slots by their token positions
+        slotEntries.sort((a, b) => (a[1].tokens[0] || 0) - (b[1].tokens[0] || 0));
+        // Extract structure based on pattern and position
+        let directObject;
+        let preposition;
+        let indirectObject;
+        let extras = {};
+        // Analyze the pattern to understand the expected structure
+        const patternParts = rule.pattern.split(/\s+/);
+        const slotPositions = {};
+        let positionCounter = 0;
+        // Map slot names to their positions in the pattern
+        for (const part of patternParts) {
+            if (part.startsWith(':')) {
+                const slotName = part.substring(1);
+                slotPositions[slotName] = positionCounter++;
+            }
+        }
+        // ADR-080: Track text slots, instruments, and excluded items
+        let textSlots;
+        let instrument;
+        let excluded;
+        // ADR-082: Track vocabulary slots and manner
+        let vocabularySlots;
+        let manner;
+        // Process slots based on the pattern structure
+        for (const [slotName, slotData] of slotEntries) {
+            const slotTokens = slotData.tokens.map((idx) => tokens[idx]);
+            // Check slot type from the match data (set by grammar engine)
+            const slotType = slotData.slotType;
+            // Handle text slots (TEXT or TEXT_GREEDY)
+            if (slotType === if_domain_1.SlotType.TEXT || slotType === if_domain_1.SlotType.TEXT_GREEDY) {
+                if (!textSlots) {
+                    textSlots = new Map();
+                }
+                textSlots.set(slotName, slotData.text);
+                continue; // Don't also add to direct/indirect objects
+            }
+            // ADR-082: Handle vocabulary slots
+            if (slotType === if_domain_1.SlotType.VOCABULARY) {
+                const slotDataAny = slotData;
+                if (!vocabularySlots) {
+                    vocabularySlots = new Map();
+                }
+                vocabularySlots.set(slotName, {
+                    word: slotDataAny.matchedWord || slotData.text.toLowerCase(),
+                    category: slotDataAny.category || ''
+                });
+                continue; // Don't also add to direct/indirect objects
+            }
+            // ADR-082: Handle manner slots
+            if (slotType === if_domain_1.SlotType.MANNER) {
+                const slotDataAny = slotData;
+                manner = slotDataAny.manner || slotData.text.toLowerCase();
+                continue; // Don't also add to direct/indirect objects
+            }
+            // ADR-084: Handle direction slots - put in extras.direction
+            if (slotType === if_domain_1.SlotType.DIRECTION) {
+                const directionText = slotData.text.toLowerCase();
+                const directionConstant = (0, direction_mappings_1.parseDirection)(directionText);
+                extras.direction = directionConstant || directionText;
+                continue; // Don't also add to direct/indirect objects
+            }
+            // Build base noun phrase
+            const phrase = {
+                tokens: slotData.tokens,
+                text: slotData.text,
+                head: slotTokens[slotTokens.length - 1]?.normalized || slotData.text,
+                modifiers: [],
+                articles: [],
+                determiners: [],
+                candidates: [slotData.text]
+            };
+            // ADR-080 Phase 2: Add multi-object support
+            const slotDataAny = slotData;
+            if (slotDataAny.isAll) {
+                phrase.isAll = true;
+                // Extract excluded items for "all but X" patterns
+                if (slotDataAny.excluded && slotDataAny.excluded.length > 0) {
+                    excluded = slotDataAny.excluded.map((item) => ({
+                        tokens: item.tokens,
+                        text: item.text,
+                        head: item.text.split(' ').pop() || item.text,
+                        modifiers: [],
+                        articles: [],
+                        determiners: [],
+                        candidates: [item.text]
+                    }));
+                }
+            }
+            if (slotDataAny.isList && slotDataAny.items) {
+                phrase.isList = true;
+                phrase.items = slotDataAny.items.map((item) => ({
+                    tokens: item.tokens,
+                    text: item.text,
+                    head: item.text.split(' ').pop() || item.text,
+                    modifiers: [],
+                    articles: [],
+                    determiners: [],
+                    candidates: [item.text],
+                    entityId: item.entityId // ADR-089: preserve pre-resolved entity ID
+                }));
+            }
+            // ADR-089: Copy pre-resolved entity ID from pronoun resolution
+            if (slotDataAny.entityId) {
+                phrase.entityId = slotDataAny.entityId;
+            }
+            // ADR-104: Mark if this was a pronoun (for implicit inference)
+            if (slotDataAny.isPronoun) {
+                phrase.wasPronoun = true;
+            }
+            // Handle instrument slots
+            if (slotType === if_domain_1.SlotType.INSTRUMENT) {
+                instrument = phrase;
+                continue; // Don't also add to direct/indirect objects
+            }
+            // Determine where this slot should go based on the pattern
+            if (rule.pattern.includes(' with :' + slotName)) {
+                // This slot comes after 'with', put it in extras
+                extras[slotName] = phrase;
+            }
+            else if (rule.pattern.includes('give :recipient :item')) {
+                // Special case for give patterns
+                if (slotName === 'item') {
+                    directObject = phrase;
+                }
+                else if (slotName === 'recipient') {
+                    indirectObject = phrase;
+                }
+            }
+            else if (rule.pattern.includes('give :item to :recipient')) {
+                // Give with 'to' pattern
+                if (slotName === 'item') {
+                    directObject = phrase;
+                }
+                else if (slotName === 'recipient') {
+                    indirectObject = phrase;
+                }
+            }
+            else if (rule.pattern.includes('show :recipient :item')) {
+                // Special case for show recipient item
+                if (slotName === 'item') {
+                    directObject = phrase;
+                }
+                else if (slotName === 'recipient') {
+                    indirectObject = phrase;
+                }
+            }
+            else if (rule.pattern.includes('show :item to :recipient')) {
+                // Show with 'to' pattern
+                if (slotName === 'item') {
+                    directObject = phrase;
+                }
+                else if (slotName === 'recipient') {
+                    indirectObject = phrase;
+                }
+            }
+            else if (rule.pattern.includes(':item from :container')) {
+                // Take from pattern
+                if (slotName === 'item') {
+                    directObject = phrase;
+                }
+                else if (slotName === 'container') {
+                    indirectObject = phrase;
+                }
+            }
+            else {
+                // General case: first slot is direct object, second is indirect object
+                const slotPosition = slotPositions[slotName];
+                if (slotPosition === 0 && !directObject) {
+                    directObject = phrase;
+                }
+                else if (slotPosition === 1 && !indirectObject) {
+                    indirectObject = phrase;
+                }
+                else {
+                    // Additional slots or already assigned slots go to extras
+                    if (!extras[slotName]) {
+                        extras[slotName] = phrase;
+                    }
+                }
+            }
+        }
+        // Find prepositions between direct and indirect objects
+        if (directObject && indirectObject) {
+            const directObjLastToken = directObject.tokens[directObject.tokens.length - 1];
+            const indirectObjFirstToken = indirectObject.tokens[0];
+            for (let i = directObjLastToken + 1; i < indirectObjFirstToken; i++) {
+                if (tokens[i].partOfSpeech.includes(world_model_1.PartOfSpeech.PREPOSITION)) {
+                    preposition = {
+                        tokens: [i],
+                        text: tokens[i].word
+                    };
+                    break;
+                }
+            }
+        }
+        // For direction commands, handle specially
+        if (rule.action === 'if.action.going' && !directObject) {
+            // Extract direction from pattern
+            const directionToken = tokens.find(t => t.candidates.some((c) => c.type === if_domain_1.PartOfSpeech.DIRECTION) ||
+                ['north', 'south', 'east', 'west', 'up', 'down', 'in', 'out', 'n', 's', 'e', 'w', 'u', 'd'].includes(t.normalized));
+            if (directionToken) {
+                return {
+                    tokens,
+                    verb: verbPhrase,
+                    pattern: 'DIRECTION_ONLY',
+                    confidence: match.confidence,
+                    action: rule.action,
+                    direction: directionToken.normalized
+                };
+            }
+        }
+        // Determine pattern type
+        let pattern = 'VERB_ONLY';
+        if (directObject && indirectObject) {
+            if (preposition) {
+                pattern = 'VERB_NOUN_PREP_NOUN';
+            }
+            else {
+                pattern = 'VERB_NOUN_NOUN';
+            }
+        }
+        else if (directObject) {
+            pattern = 'VERB_NOUN';
+        }
+        const candidate = {
+            tokens,
+            verb: verbPhrase,
+            directObject,
+            preposition,
+            indirectObject,
+            pattern,
+            confidence: match.confidence,
+            action: rule.action,
+            // ADR-080 additions
+            textSlots,
+            instrument,
+            excluded,
+            // ADR-082 additions
+            vocabularySlots,
+            manner
+        };
+        // Add extras if present
+        if (Object.keys(extras).length > 0) {
+            candidate.extras = extras;
+        }
+        return candidate;
+    }
+    /**
+     * Register story-specific grammar rules
+     * @deprecated Use getStoryGrammar() for full API
+     */
+    registerGrammar(pattern, action, constraints) {
+        const builder = this.grammarEngine.createBuilder().define(pattern)
+            .mapsTo(action);
+        // Apply constraints if provided
+        if (constraints) {
+            for (const [slot, constraint] of Object.entries(constraints)) {
+                builder.where(slot, constraint);
+            }
+        }
+        builder.build();
+    }
+    /**
+     * Get the grammar builder for story-specific rules.
+     * Stories use this to define custom grammar patterns.
+     *
+     * ADR-084: Returns the grammar builder directly instead of a wrapper,
+     * giving stories full access to all PatternBuilder methods.
+     */
+    getStoryGrammar() {
+        return this.grammarEngine.createBuilder();
+    }
+    /**
+     * Get candidate interpretations for a token
+     */
+    getTokenCandidates(word) {
+        const entries = if_domain_1.vocabularyRegistry.lookup(word);
+        return entries.map((entry) => ({
+            partOfSpeech: entry.partOfSpeech,
+            mapsTo: entry.mapsTo,
+            priority: entry.priority || 0,
+            source: entry.source,
+            metadata: entry.metadata
+        }));
+    }
+    /**
+     * Old tokenize method for compatibility
+     */
+    tokenize(input) {
+        const richTokens = this.tokenizeRich(input);
+        // Convert to old format
+        return richTokens.map(rt => ({
+            word: rt.word,
+            normalized: rt.normalized,
+            position: rt.position,
+            candidates: this.getTokenCandidates(rt.normalized)
+        }));
+    }
+    /**
+     * Parse with errors for testing compatibility
+     */
+    parseWithErrors(input, options) {
+        // Merge options with current parser options
+        const mergedOptions = { ...this.options, ...options };
+        // First, tokenize to check for unknown words
+        const tokens = this.tokenizeRich(input);
+        const errors = [];
+        // Check for unknown words
+        for (const token of tokens) {
+            if (token.partOfSpeech.includes(world_model_1.PartOfSpeech.UNKNOWN) &&
+                token.candidates.length === 0) {
+                errors.push({
+                    type: if_domain_1.ParseErrorType.UNKNOWN_WORD,
+                    message: `Unknown word: ${token.word}`,
+                    words: [token.word],
+                    position: token.position
+                });
+            }
+        }
+        // If we have unknown words and allowPartial is true, we should still try to parse
+        const hasUnknownWords = errors.length > 0;
+        const shouldContinue = !hasUnknownWords || mergedOptions.allowPartial;
+        if (!shouldContinue) {
+            return {
+                candidates: [],
+                errors,
+                partial: false
+            };
+        }
+        // Try to parse
+        const result = this.parse(input);
+        if (result.success) {
+            // Convert to old candidate format for test compatibility
+            const candidate = {
+                action: result.value.action,
+                originalInput: input,
+                tokens: this.tokenize(input),
+                pattern: result.value.pattern,
+                confidence: result.value.confidence
+            };
+            // Add noun information
+            if (result.value.structure.directObject) {
+                candidate.nounText = result.value.structure.directObject.text;
+                candidate.nounCandidates = result.value.structure.directObject.candidates;
+            }
+            // Add preposition
+            if (result.value.structure.preposition) {
+                candidate.preposition = result.value.structure.preposition.text;
+            }
+            // Add indirect object
+            if (result.value.structure.indirectObject) {
+                candidate.secondNounText = result.value.structure.indirectObject.text;
+                candidate.secondNounCandidates = result.value.structure.indirectObject.candidates;
+            }
+            // Filter by confidence if specified
+            const candidateConfidence = candidate.confidence || 0;
+            const candidates = mergedOptions.minConfidence !== undefined &&
+                candidateConfidence < mergedOptions.minConfidence
+                ? []
+                : [candidate];
+            return {
+                candidates,
+                errors,
+                partial: hasUnknownWords && (mergedOptions.allowPartial === true)
+            };
+        }
+        else {
+            // If we already have errors from unknown words, return those
+            if (errors.length > 0) {
+                return {
+                    candidates: [],
+                    errors,
+                    partial: mergedOptions.allowPartial === true
+                };
+            }
+            // Other parsing errors
+            const error = {
+                type: if_domain_1.ParseErrorType.PATTERN_MISMATCH,
+                message: result.error.message,
+                position: result.error.position
+            };
+            return {
+                candidates: [],
+                errors: [error],
+                partial: false
+            };
+        }
+    }
+    /**
+     * Add a custom verb to the parser vocabulary
+     * @param actionId The action ID this verb maps to
+     * @param verbs Array of verb forms to recognize
+     * @param pattern Optional grammar pattern for the verb (e.g., 'VERB_OBJ')
+     * @param prepositions Optional prepositions this verb can use
+     */
+    addVerb(actionId, verbs, pattern, prepositions) {
+        const verbDef = {
+            actionId,
+            verbs,
+            pattern: pattern || 'VERB_ONLY',
+            prepositions
+        };
+        if_domain_1.vocabularyRegistry.registerDynamicVerbs([verbDef], 'story');
+        // Also register grammar patterns for the verb
+        const grammarBuilder = this.grammarEngine.createBuilder();
+        for (const verb of verbs) {
+            // Register patterns based on the pattern type
+            if (pattern === 'VERB_OBJ' || pattern === 'VERB_NOUN') {
+                // Register verb + object pattern
+                grammarBuilder.define(`${verb} :object`)
+                    .mapsTo(actionId)
+                    .withPriority(150)
+                    .build();
+            }
+            else if (pattern === 'VERB_PREP_NOUN' && prepositions) {
+                // Register verb + preposition + object patterns
+                for (const prep of prepositions) {
+                    grammarBuilder.define(`${verb} ${prep} :object`)
+                        .mapsTo(actionId)
+                        .withPriority(150)
+                        .build();
+                }
+            }
+            else if (pattern === 'VERB_NOUN_PREP_NOUN' && prepositions) {
+                // Register verb + object + preposition + object patterns
+                for (const prep of prepositions) {
+                    grammarBuilder.define(`${verb} :object1 ${prep} :object2`)
+                        .mapsTo(actionId)
+                        .withPriority(150)
+                        .build();
+                }
+            }
+            else {
+                // Default: verb only pattern
+                grammarBuilder.define(verb)
+                    .mapsTo(actionId)
+                    .withPriority(150)
+                    .build();
+            }
+        }
+        // Emit debug event if configured
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'vocabulary.add_verb',
+                data: {
+                    actionId,
+                    verbs,
+                    pattern,
+                    prepositions
+                }
+            });
+        }
+    }
+    /**
+     * Add a custom noun/synonym to the parser vocabulary
+     * @param word The word to add
+     * @param canonical The canonical form it maps to
+     */
+    addNoun(word, canonical) {
+        // For now, nouns are handled through the world model's entity names
+        // This method is provided for future extension when we add a noun registry
+        // Emit debug event if configured
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'vocabulary.add_noun',
+                data: {
+                    word,
+                    canonical
+                }
+            });
+        }
+    }
+    /**
+     * Add a custom adjective to the parser vocabulary
+     * @param word The adjective to add
+     */
+    addAdjective(word) {
+        // Adjectives are currently recognized but not stored in a registry
+        // This method is provided for future extension
+        // Emit debug event if configured
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'vocabulary.add_adjective',
+                data: {
+                    word
+                }
+            });
+        }
+    }
+    /**
+     * Add a custom preposition to the parser vocabulary
+     * @param word The preposition to add
+     */
+    addPreposition(word) {
+        if_domain_1.vocabularyRegistry.registerPrepositions([word]);
+        // Also register common grammar patterns that use this preposition
+        // This allows actions like "put X <preposition> Y" to work
+        const grammarBuilder = this.grammarEngine.createBuilder();
+        grammarBuilder.define(`put :object ${word} :location`)
+            .mapsTo('if.action.putting')
+            .withPriority(150)
+            .build();
+        grammarBuilder.define(`place :object ${word} :location`)
+            .mapsTo('if.action.putting')
+            .withPriority(150)
+            .build();
+        // Emit debug event if configured
+        if (this.onDebugEvent) {
+            this.onDebugEvent({
+                id: `parser_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                timestamp: Date.now(),
+                subsystem: 'parser',
+                type: 'vocabulary.add_preposition',
+                data: {
+                    word
+                }
+            });
+        }
+    }
+    /**
+     * Build a detailed parse error from failure analysis
+     */
+    buildParseError(input, analysis) {
+        const { code, messageId, context } = analysis;
+        // Generate fallback message based on error code and context
+        let message;
+        switch (code) {
+            case 'NO_VERB':
+                message = "I beg your pardon?";
+                break;
+            case 'UNKNOWN_VERB':
+                message = context.verb
+                    ? `I don't know the verb "${context.verb}".`
+                    : "I don't understand that sentence.";
+                break;
+            case 'MISSING_OBJECT':
+                message = context.verb
+                    ? `What do you want to ${context.verb}?`
+                    : "What do you want to do that to?";
+                break;
+            case 'MISSING_INDIRECT':
+                message = context.verb
+                    ? `${capitalize(context.verb)} it where?`
+                    : "Where do you want to do that?";
+                break;
+            case 'ENTITY_NOT_FOUND':
+                message = context.noun
+                    ? `I don't see any "${context.noun}" here.`
+                    : "I don't see that here.";
+                break;
+            case 'SCOPE_VIOLATION':
+                message = context.noun
+                    ? `You can't reach the ${context.noun}.`
+                    : "You can't reach that.";
+                break;
+            case 'AMBIGUOUS_INPUT':
+                message = context.noun
+                    ? `Which ${context.noun} do you mean?`
+                    : "Which do you mean?";
+                break;
+            default:
+                message = "I don't understand that.";
+        }
+        return {
+            type: 'PARSE_ERROR',
+            code,
+            messageId,
+            message,
+            input,
+            verb: context.verb,
+            failedWord: context.noun || context.verb,
+            slot: context.slot
+        };
+    }
+    // ============================================
+    // Pronoun Context Methods (ADR-089 Phase B)
+    // ============================================
+    /**
+     * Update pronoun context after a successful command execution
+     * Called by the engine after command execution succeeds
+     * @param command The validated command with resolved entity IDs
+     * @param turnNumber Current turn number
+     */
+    updatePronounContext(command, turnNumber) {
+        if (this.worldContext?.world) {
+            this.pronounContext.updateFromCommand(command, this.worldContext.world, turnNumber);
+        }
+    }
+    /**
+     * Register an entity that was mentioned in context
+     * Used when entities are referenced outside of standard parsing
+     * @param entityId The entity's ID
+     * @param text How the player referred to it
+     * @param turnNumber Current turn number
+     */
+    registerPronounEntity(entityId, text, turnNumber) {
+        if (this.worldContext?.world) {
+            this.pronounContext.registerEntity(entityId, text, this.worldContext.world, turnNumber);
+        }
+    }
+    /**
+     * Reset the pronoun context
+     * Called on game restart or when context should be cleared
+     */
+    resetPronounContext() {
+        this.pronounContext.reset();
+    }
+    /**
+     * Get the last successfully parsed command
+     * Used for "again" / "g" command support
+     */
+    getLastCommand() {
+        return this.pronounContext.getLastCommand();
+    }
+    /**
+     * Get the pronoun context manager (for testing/debugging)
+     */
+    getPronounContextManager() {
+        return this.pronounContext;
+    }
+}
+exports.EnglishParser = EnglishParser;
+/**
+ * Capitalize the first letter of a string
+ */
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=english-parser.js.map