@sharpee/lang-en-us 0.9.61-beta

package/dist-npm/language-provider.d.ts

@@ -0,0 +1,159 @@
+/**
+ * English Language Provider
+ *
+ * Self-contained language implementation with no external dependencies
+ * Enhanced to support getMessage interface for text service
+ */
+import { ParserLanguageProvider, ActionHelp, VerbVocabulary, DirectionVocabulary, SpecialVocabulary, LanguageGrammarPattern } from '@sharpee/if-domain';
+import { NarrativeContext } from './perspective';
+import { FormatterRegistry, FormatterContext, EntityInfo } from './formatters';
+/**
+ * English language data and rules
+ */
+export declare class EnglishLanguageProvider implements ParserLanguageProvider {
+    readonly languageCode = "en-US";
+    readonly languageName = "English (US)";
+    readonly textDirection: "ltr";
+    private messages;
+    private customActionPatterns;
+    private narrativeContext;
+    private formatterRegistry;
+    private entityLookup?;
+    constructor();
+    /**
+     * Load core system messages (command failures, etc.)
+     * These are used by text-service for command.failed events
+     */
+    private loadCoreMessages;
+    /**
+     * Set narrative settings for perspective-aware message resolution (ADR-089)
+     *
+     * This should be called by the engine after loading a story to configure
+     * how {You}, {your}, {take} placeholders are resolved.
+     *
+     * @param settings Narrative settings from story config
+     */
+    setNarrativeSettings(settings: NarrativeContext): void;
+    /**
+     * Get current narrative context
+     */
+    getNarrativeContext(): NarrativeContext;
+    /**
+     * Load messages from all action language definitions
+     */
+    private loadActionMessages;
+    /**
+     * Load NPC messages (ADR-070)
+     */
+    private loadNpcMessages;
+    /**
+     * Get a message by its ID with optional parameter substitution
+     *
+     * Supports three types of placeholders:
+     * 1. Perspective placeholders (ADR-089): {You}, {your}, {take}, etc.
+     *    - Resolved based on narrative context (1st/2nd/3rd person)
+     * 2. Formatted placeholders (ADR-095): {a:item}, {items:list}, etc.
+     *    - Applies formatters before substitution
+     * 3. Simple placeholders: {item}, {target}, etc.
+     *    - Replaced with values from params object
+     *
+     * @param messageId Full message ID (e.g., 'if.action.taking.taken')
+     * @param params Parameters to substitute in the message
+     * @returns The resolved message text, or null if not found
+     */
+    getMessage(messageId: string, params?: Record<string, any>): string;
+    /**
+     * Set entity lookup function for formatters (ADR-095)
+     *
+     * This allows formatters to look up entity info (nounType, etc.)
+     * for proper article selection.
+     *
+     * @param lookup Function that returns EntityInfo for an entity ID
+     */
+    setEntityLookup(lookup: (id: string) => EntityInfo | undefined): void;
+    /**
+     * Register a custom formatter (ADR-095)
+     *
+     * Stories can register custom formatters for special formatting needs.
+     *
+     * @param name Formatter name (used in templates as {name:placeholder})
+     * @param formatter Formatter function
+     */
+    registerFormatter(name: string, formatter: (value: any, context: FormatterContext) => string): void;
+    /**
+     * Get the formatter registry (for testing or advanced use)
+     */
+    getFormatterRegistry(): FormatterRegistry;
+    /**
+     * Check if a message exists
+     * @param messageId The message identifier
+     * @returns True if the message exists
+     */
+    hasMessage(messageId: string): boolean;
+    /**
+     * Get patterns/aliases for an action
+     * @param actionId The action identifier (e.g., 'if.action.taking')
+     * @returns Array of patterns or undefined if action not found
+     */
+    getActionPatterns(actionId: string): string[] | undefined;
+    /**
+     * Get structured help information for an action
+     * @param actionId The action identifier (e.g., 'if.action.taking')
+     * @returns Structured help information or undefined if not found
+     */
+    getActionHelp(actionId: string): ActionHelp | undefined;
+    /**
+     * Get all supported actions
+     * @returns Array of action IDs
+     */
+    getSupportedActions(): string[];
+    /**
+     * Get entity name/description
+     * @param entity Entity object or ID
+     * @returns Entity name or fallback
+     */
+    getEntityName(entity: any): string;
+    /**
+     * Get all messages for a given action
+     * @param actionId Action identifier
+     * @returns Map of message keys to messages
+     */
+    getActionMessages(actionId: string): Map<string, string> | null;
+    getVerbs(): VerbVocabulary[];
+    getDirections(): DirectionVocabulary[];
+    getSpecialVocabulary(): SpecialVocabulary;
+    getCommonAdjectives(): string[];
+    getCommonNouns(): string[];
+    getPrepositions(): string[];
+    getDeterminers(): string[];
+    getConjunctions(): string[];
+    getNumbers(): string[];
+    getGrammarPatterns(): LanguageGrammarPattern[];
+    lemmatize(word: string): string;
+    expandAbbreviation(abbreviation: string): string | null;
+    formatList(items: string[], conjunction?: 'and' | 'or'): string;
+    getIndefiniteArticle(noun: string): string;
+    pluralize(noun: string): string;
+    isIgnoreWord(word: string): boolean;
+    /**
+     * Add a custom message to the language provider
+     * @param messageId The message identifier (e.g., 'custom.action.message')
+     * @param template The message template with optional {param} placeholders
+     */
+    addMessage(messageId: string, template: string): void;
+    /**
+     * Add help information for a custom action
+     * @param actionId The action identifier (e.g., 'custom.action.foo')
+     * @param help The help information including usage, description, examples
+     */
+    addActionHelp(actionId: string, help: ActionHelp): void;
+    /**
+     * Add custom patterns/aliases for an action
+     * @param actionId The action identifier
+     * @param patterns Array of verb patterns/aliases
+     */
+    addActionPatterns(actionId: string, patterns: string[]): void;
+}
+declare const _default: EnglishLanguageProvider;
+export default _default;
+//# sourceMappingURL=language-provider.d.ts.map

package/dist-npm/language-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-provider.d.ts","sourceRoot":"","sources":["../src/language-provider.ts"],"names":[],"mappings":"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"}

package/dist-npm/language-provider.js

@@ -0,0 +1,527 @@
+"use strict";
+/**
+ * English Language Provider
+ *
+ * Self-contained language implementation with no external dependencies
+ * Enhanced to support getMessage interface for text service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnglishLanguageProvider = void 0;
+const verbs_1 = require("./data/verbs");
+const words_1 = require("./data/words");
+const actions_1 = require("./actions");
+const npc_1 = require("./npc");
+const perspective_1 = require("./perspective");
+const formatters_1 = require("./formatters");
+// Types are now imported from @sharpee/if-domain
+/**
+ * English language data and rules
+ */
+class EnglishLanguageProvider {
+    languageCode = 'en-US';
+    languageName = 'English (US)';
+    textDirection = 'ltr';
+    // Message storage
+    messages = new Map();
+    customActionPatterns = new Map();
+    // Narrative context for perspective-aware message resolution (ADR-089)
+    narrativeContext = perspective_1.DEFAULT_NARRATIVE_CONTEXT;
+    // Formatter registry for {a:item}, {items:list}, etc. (ADR-095)
+    formatterRegistry;
+    // Entity lookup function for formatters (set by engine)
+    entityLookup;
+    constructor() {
+        // Initialize formatter registry
+        this.formatterRegistry = (0, formatters_1.createFormatterRegistry)();
+        // Load core system messages
+        this.loadCoreMessages();
+        // Load all action messages
+        this.loadActionMessages();
+        // Load NPC messages (ADR-070)
+        this.loadNpcMessages();
+    }
+    /**
+     * Load core system messages (command failures, etc.)
+     * These are used by text-service for command.failed events
+     */
+    loadCoreMessages() {
+        const coreMessages = {
+            'core.entity_not_found': "You can't see any such thing.",
+            'core.ambiguous_reference': "Which do you mean?",
+            'core.disambiguation_prompt': "Which do you mean: {options}?",
+            'core.command_not_understood': "I don't understand that command.",
+            'core.command_failed': "I don't understand that.",
+            // Game lifecycle messages
+            'game.started.banner': "{title}\nBy {author}\n\nType HELP for instructions.",
+        };
+        for (const [key, value] of Object.entries(coreMessages)) {
+            this.messages.set(key, value);
+        }
+    }
+    /**
+     * Set narrative settings for perspective-aware message resolution (ADR-089)
+     *
+     * This should be called by the engine after loading a story to configure
+     * how {You}, {your}, {take} placeholders are resolved.
+     *
+     * @param settings Narrative settings from story config
+     */
+    setNarrativeSettings(settings) {
+        this.narrativeContext = settings;
+    }
+    /**
+     * Get current narrative context
+     */
+    getNarrativeContext() {
+        return this.narrativeContext;
+    }
+    /**
+     * Load messages from all action language definitions
+     */
+    loadActionMessages() {
+        for (const actionLang of actions_1.standardActionLanguage) {
+            if (actionLang.messages) {
+                Object.entries(actionLang.messages).forEach(([key, value]) => {
+                    // Store with full action ID prefix
+                    const fullKey = `${actionLang.actionId}.${key}`;
+                    this.messages.set(fullKey, value);
+                });
+            }
+        }
+    }
+    /**
+     * Load NPC messages (ADR-070)
+     */
+    loadNpcMessages() {
+        if (npc_1.npcLanguage.messages) {
+            for (const [key, value] of Object.entries(npc_1.npcLanguage.messages)) {
+                this.messages.set(key, value);
+            }
+        }
+    }
+    /**
+     * Get a message by its ID with optional parameter substitution
+     *
+     * Supports three types of placeholders:
+     * 1. Perspective placeholders (ADR-089): {You}, {your}, {take}, etc.
+     *    - Resolved based on narrative context (1st/2nd/3rd person)
+     * 2. Formatted placeholders (ADR-095): {a:item}, {items:list}, etc.
+     *    - Applies formatters before substitution
+     * 3. Simple placeholders: {item}, {target}, etc.
+     *    - Replaced with values from params object
+     *
+     * @param messageId Full message ID (e.g., 'if.action.taking.taken')
+     * @param params Parameters to substitute in the message
+     * @returns The resolved message text, or null if not found
+     */
+    getMessage(messageId, params) {
+        let message = this.messages.get(messageId);
+        if (!message) {
+            return messageId; // Return the ID as fallback
+        }
+        // Step 1: Resolve perspective placeholders (ADR-089)
+        // This handles {You}, {your}, {take}, etc.
+        message = (0, perspective_1.resolvePerspectivePlaceholders)(message, this.narrativeContext);
+        // Step 2: Apply formatters and substitute parameters (ADR-095)
+        if (params) {
+            const context = {
+                getEntity: this.entityLookup,
+            };
+            message = (0, formatters_1.formatMessage)(message, params, this.formatterRegistry, context);
+        }
+        return message;
+    }
+    /**
+     * Set entity lookup function for formatters (ADR-095)
+     *
+     * This allows formatters to look up entity info (nounType, etc.)
+     * for proper article selection.
+     *
+     * @param lookup Function that returns EntityInfo for an entity ID
+     */
+    setEntityLookup(lookup) {
+        this.entityLookup = lookup;
+    }
+    /**
+     * Register a custom formatter (ADR-095)
+     *
+     * Stories can register custom formatters for special formatting needs.
+     *
+     * @param name Formatter name (used in templates as {name:placeholder})
+     * @param formatter Formatter function
+     */
+    registerFormatter(name, formatter) {
+        this.formatterRegistry.set(name, formatter);
+    }
+    /**
+     * Get the formatter registry (for testing or advanced use)
+     */
+    getFormatterRegistry() {
+        return this.formatterRegistry;
+    }
+    /**
+     * Check if a message exists
+     * @param messageId The message identifier
+     * @returns True if the message exists
+     */
+    hasMessage(messageId) {
+        return this.messages.has(messageId);
+    }
+    /**
+     * Get patterns/aliases for an action
+     * @param actionId The action identifier (e.g., 'if.action.taking')
+     * @returns Array of patterns or undefined if action not found
+     */
+    getActionPatterns(actionId) {
+        // First check custom patterns
+        const customPatterns = this.customActionPatterns.get(actionId);
+        // Then check standard action language
+        const actionLang = actions_1.standardActionLanguage.find(lang => lang.actionId === actionId);
+        const standardPatterns = actionLang?.patterns;
+        // Merge both sources if they exist
+        if (customPatterns && standardPatterns) {
+            return [...standardPatterns, ...customPatterns];
+        }
+        return customPatterns || standardPatterns;
+    }
+    /**
+     * Get structured help information for an action
+     * @param actionId The action identifier (e.g., 'if.action.taking')
+     * @returns Structured help information or undefined if not found
+     */
+    getActionHelp(actionId) {
+        const actionLang = actions_1.standardActionLanguage.find(lang => lang.actionId === actionId);
+        if (!actionLang) {
+            return undefined;
+        }
+        // Extract verbs from patterns
+        const verbs = [];
+        if (actionLang.patterns) {
+            actionLang.patterns.forEach(pattern => {
+                // Extract the verb from patterns like "take [something]"
+                const match = pattern.match(/^(\w+)/);
+                if (match) {
+                    const verb = match[1].toUpperCase();
+                    if (!verbs.includes(verb)) {
+                        verbs.push(verb);
+                    }
+                }
+            });
+        }
+        // Parse examples from help object
+        let examples = [];
+        if (actionLang.help?.examples) {
+            // Split by comma and trim
+            examples = actionLang.help.examples.split(',').map(ex => ex.trim());
+        }
+        return {
+            description: actionLang.help?.description || 'No description available.',
+            verbs,
+            examples,
+            summary: actionLang.help?.summary
+        };
+    }
+    /**
+     * Get all supported actions
+     * @returns Array of action IDs
+     */
+    getSupportedActions() {
+        return actions_1.standardActionLanguage.map(lang => lang.actionId);
+    }
+    /**
+     * Get entity name/description
+     * @param entity Entity object or ID
+     * @returns Entity name or fallback
+     */
+    getEntityName(entity) {
+        if (!entity)
+            return 'something';
+        // If it's a string, return it
+        if (typeof entity === 'string') {
+            return entity;
+        }
+        // Try various properties
+        if (entity.name) {
+            return entity.name;
+        }
+        // Try identity trait
+        if (entity.traits && entity.traits.get) {
+            const identity = entity.traits.get('IDENTITY');
+            if (identity && identity.name) {
+                return identity.name;
+            }
+        }
+        // Try direct trait access
+        if (entity.get && typeof entity.get === 'function') {
+            const identity = entity.get('IDENTITY');
+            if (identity && identity.name) {
+                return identity.name;
+            }
+        }
+        // Fall back to ID
+        if (entity.id) {
+            return entity.id;
+        }
+        return 'something';
+    }
+    /**
+     * Get all messages for a given action
+     * @param actionId Action identifier
+     * @returns Map of message keys to messages
+     */
+    getActionMessages(actionId) {
+        const actionMessages = new Map();
+        const prefix = `${actionId}.`;
+        // Find all messages for this action
+        for (const [key, value] of this.messages) {
+            if (key.startsWith(prefix)) {
+                const messageKey = key.substring(prefix.length);
+                actionMessages.set(messageKey, value);
+            }
+        }
+        return actionMessages.size > 0 ? actionMessages : null;
+    }
+    getVerbs() {
+        return verbs_1.englishVerbs.map(verb => ({
+            actionId: verb.action,
+            verbs: verb.verbs,
+            pattern: verb.requiresObject ?
+                (verb.allowsIndirectObject ? 'VERB_OBJ_PREP_OBJ' : 'VERB_OBJ') :
+                'VERB_ONLY',
+            prepositions: verb.allowsIndirectObject ? ['in', 'on', 'to', 'with'] : undefined
+        }));
+    }
+    getDirections() {
+        return [
+            { direction: 'north', words: ['north'], abbreviations: ['n'] },
+            { direction: 'south', words: ['south'], abbreviations: ['s'] },
+            { direction: 'east', words: ['east'], abbreviations: ['e'] },
+            { direction: 'west', words: ['west'], abbreviations: ['w'] },
+            { direction: 'northeast', words: ['northeast'], abbreviations: ['ne'] },
+            { direction: 'northwest', words: ['northwest'], abbreviations: ['nw'] },
+            { direction: 'southeast', words: ['southeast'], abbreviations: ['se'] },
+            { direction: 'southwest', words: ['southwest'], abbreviations: ['sw'] },
+            { direction: 'up', words: ['up', 'upward', 'upwards'], abbreviations: ['u'] },
+            { direction: 'down', words: ['down', 'downward', 'downwards'], abbreviations: ['d'] },
+            { direction: 'in', words: ['in', 'inside'] },
+            { direction: 'out', words: ['out', 'outside'] }
+        ];
+    }
+    getSpecialVocabulary() {
+        return {
+            articles: words_1.englishWords.articles,
+            pronouns: words_1.englishWords.pronouns,
+            allWords: ['all', 'everything', 'every'],
+            exceptWords: ['except', 'but']
+        };
+    }
+    getCommonAdjectives() {
+        return words_1.englishWords.commonAdjectives;
+    }
+    getCommonNouns() {
+        return words_1.englishWords.commonNouns || [];
+    }
+    getPrepositions() {
+        return words_1.englishWords.prepositions;
+    }
+    getDeterminers() {
+        return words_1.englishWords.determiners || [];
+    }
+    getConjunctions() {
+        return words_1.englishWords.conjunctions || [];
+    }
+    getNumbers() {
+        return words_1.englishWords.numberWords || [];
+    }
+    getGrammarPatterns() {
+        return [
+            {
+                name: 'verb_noun_prep_noun',
+                pattern: 'VERB NOUN+ PREP NOUN+',
+                example: 'put ball in box',
+                priority: 100
+            },
+            {
+                name: 'verb_prep_noun',
+                pattern: 'VERB PREP NOUN+',
+                example: 'look at painting',
+                priority: 90
+            },
+            {
+                name: 'verb_noun',
+                pattern: 'VERB NOUN+',
+                example: 'take ball',
+                priority: 80
+            },
+            {
+                name: 'verb_only',
+                pattern: 'VERB',
+                example: 'look',
+                priority: 70
+            },
+            {
+                name: 'direction_only',
+                pattern: 'DIRECTION',
+                example: 'north',
+                priority: 60
+            }
+        ];
+    }
+    lemmatize(word) {
+        if (!word)
+            return '';
+        const lower = word.toLowerCase();
+        // Check irregular plurals
+        const singular = words_1.irregularPlurals.get(lower);
+        if (singular)
+            return singular;
+        // Handle special cases first
+        if (lower === 'yes' || lower === 'ties')
+            return lower;
+        // Simple rules for common endings
+        if (lower.endsWith('ies') && lower.length > 4) {
+            return lower.slice(0, -3) + 'y';
+        }
+        if (lower.endsWith('es') && lower.length > 3) {
+            // Don't lemmatize words like 'yes'
+            if (lower === 'yes')
+                return lower;
+            return lower.slice(0, -2);
+        }
+        if (lower.endsWith('s') && !lower.endsWith('ss') && lower.length > 2) {
+            return lower.slice(0, -1);
+        }
+        if (lower.endsWith('ed') && lower.length > 3) {
+            // Handle double consonants (dropped -> drop)
+            if (lower.length > 4 && lower[lower.length - 3] === lower[lower.length - 4]) {
+                return lower.slice(0, -3);
+            }
+            return lower.slice(0, -2);
+        }
+        if (lower.endsWith('ing') && lower.length > 4 && !lower.includes('-')) {
+            return lower.slice(0, -3);
+        }
+        return lower;
+    }
+    expandAbbreviation(abbreviation) {
+        return words_1.abbreviations.get(abbreviation.toLowerCase()) || null;
+    }
+    formatList(items, conjunction = 'and') {
+        if (items.length === 0)
+            return '';
+        if (items.length === 1)
+            return items[0];
+        if (items.length === 2)
+            return `${items[0]} ${conjunction} ${items[1]}`;
+        const allButLast = items.slice(0, -1);
+        const last = items[items.length - 1];
+        return `${allButLast.join(', ')}, ${conjunction} ${last}`;
+    }
+    getIndefiniteArticle(noun) {
+        if (!noun || noun.length === 0)
+            return 'a';
+        const firstChar = noun[0].toLowerCase();
+        const vowels = ['a', 'e', 'i', 'o', 'u'];
+        // Special cases
+        if (noun.toLowerCase().startsWith('hour'))
+            return 'an';
+        if (noun.toLowerCase().startsWith('honest'))
+            return 'an';
+        if (noun.toLowerCase().startsWith('uni'))
+            return 'a';
+        if (noun.toLowerCase().startsWith('one'))
+            return 'a';
+        return vowels.includes(firstChar) ? 'an' : 'a';
+    }
+    pluralize(noun) {
+        if (!noun)
+            return 's';
+        const lower = noun.toLowerCase();
+        // Check irregular plurals - the map is plural->singular, so we need to reverse lookup
+        for (const [plural, singular] of words_1.irregularPlurals) {
+            if (singular === lower) {
+                // Preserve the case pattern of the original noun
+                if (noun === noun.toUpperCase()) {
+                    return plural.toUpperCase();
+                }
+                else if (noun[0] === noun[0].toUpperCase()) {
+                    return plural[0].toUpperCase() + plural.slice(1);
+                }
+                return plural;
+            }
+        }
+        // Regular rules
+        if (lower.endsWith('s') || lower.endsWith('x') || lower.endsWith('z') ||
+            lower.endsWith('ch') || lower.endsWith('sh')) {
+            return noun + 'es';
+        }
+        if (lower.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(lower[lower.length - 2])) {
+            // Special handling for case preservation with -ies
+            if (noun === noun.toUpperCase()) {
+                return noun.slice(0, -1) + 'IES';
+            }
+            return noun.slice(0, -1) + 'ies';
+        }
+        if (lower.endsWith('f')) {
+            return noun.slice(0, -1) + 'ves';
+        }
+        if (lower.endsWith('fe')) {
+            return noun.slice(0, -2) + 'ves';
+        }
+        return noun + 's';
+    }
+    isIgnoreWord(word) {
+        return words_1.englishWords.ignoreWords.includes(word.toLowerCase());
+    }
+    /**
+     * Add a custom message to the language provider
+     * @param messageId The message identifier (e.g., 'custom.action.message')
+     * @param template The message template with optional {param} placeholders
+     */
+    addMessage(messageId, template) {
+        this.messages.set(messageId, template);
+    }
+    /**
+     * Add help information for a custom action
+     * @param actionId The action identifier (e.g., 'custom.action.foo')
+     * @param help The help information including usage, description, examples
+     */
+    addActionHelp(actionId, help) {
+        // Store the help information associated with the action
+        // This would require maintaining a separate help registry
+        // For now, we'll store it as messages with a special prefix
+        if (help.summary) {
+            this.messages.set(`${actionId}.help.summary`, help.summary);
+        }
+        if (help.description) {
+            this.messages.set(`${actionId}.help.description`, help.description);
+        }
+        if (help.examples) {
+            help.examples.forEach((example, index) => {
+                this.messages.set(`${actionId}.help.example.${index}`, example);
+            });
+        }
+    }
+    /**
+     * Add custom patterns/aliases for an action
+     * @param actionId The action identifier
+     * @param patterns Array of verb patterns/aliases
+     */
+    addActionPatterns(actionId, patterns) {
+        // Get existing custom patterns
+        const existing = this.customActionPatterns.get(actionId) || [];
+        // Merge with new patterns (avoiding duplicates)
+        const merged = [...existing];
+        for (const pattern of patterns) {
+            if (!merged.includes(pattern)) {
+                merged.push(pattern);
+            }
+        }
+        // Store the merged patterns
+        this.customActionPatterns.set(actionId, merged);
+    }
+}
+exports.EnglishLanguageProvider = EnglishLanguageProvider;
+// Default export - create an instance
+exports.default = new EnglishLanguageProvider();
+//# sourceMappingURL=language-provider.js.map