@sharpee/stdlib 0.9.108 → 0.9.110

package/actions/enhanced-types.d.ts

@@ -0,0 +1,692 @@
+/**
+ * Enhanced action system types
+ *
+ * This provides a cleaner, more author-friendly action system while
+ * maintaining the event-driven architecture. Actions return events,
+ * but the enhanced context makes it easy to create those events.
+ */
+import { ISemanticEvent } from "../../core/index";
+import { IFEntity, WorldModel } from "../../world-model/index";
+import { ScopeResolver, ScopeLevel } from '../scope/types';
+import { ValidatedCommand } from '../validation/types';
+/**
+ * Result of a scope requirement check.
+ *
+ * Used by ActionContext.requireScope() to indicate whether an entity
+ * meets the required scope level.
+ */
+export interface ScopeCheckResult {
+    /** Whether the scope requirement was met */
+    ok: boolean;
+    /**
+     * If ok is false, contains the error to return from validate().
+     * Can be spread directly into a ValidationResult.
+     */
+    error?: {
+        valid: false;
+        error: string;
+        params?: Record<string, any>;
+    };
+    /** The actual scope level of the entity (for debugging/logging) */
+    actualScope?: ScopeLevel;
+}
+/**
+ * Standard error codes for scope failures.
+ * These map to message IDs in the language layer.
+ */
+export declare const ScopeErrors: {
+    /** Entity is completely unknown to the player */
+    readonly NOT_KNOWN: "scope.not_known";
+    /** Entity is known but not currently visible */
+    readonly NOT_VISIBLE: "scope.not_visible";
+    /** Entity is visible but not physically reachable */
+    readonly NOT_REACHABLE: "scope.not_reachable";
+    /** Entity must be carried but is not in inventory */
+    readonly NOT_CARRIED: "scope.not_carried";
+    /** Generic scope failure */
+    readonly OUT_OF_SCOPE: "scope.out_of_scope";
+};
+/**
+ * Result from an implicit take attempt.
+ *
+ * Used by ActionContext.requireCarriedOrImplicitTake() to indicate
+ * whether the entity is now carried (either was already, or was
+ * successfully taken implicitly).
+ */
+export interface ImplicitTakeResult {
+    /** Whether the entity is now carried */
+    ok: boolean;
+    /**
+     * If ok is false, contains the error to return from validate().
+     * This could be a scope error (can't reach) or a take error (scenery, etc.)
+     */
+    error?: {
+        valid: false;
+        error: string;
+        params?: Record<string, any>;
+    };
+    /**
+     * Events from the implicit take action, if one was performed.
+     * Should be prepended to the main action's report events.
+     * Includes the "if.event.implicit_take" event for "(first taking the X)".
+     */
+    implicitTakeEvents?: ISemanticEvent[];
+}
+/**
+ * Unified action context interface
+ *
+ * Provides both world querying capabilities and event creation methods.
+ * This is the single context interface used by all actions.
+ *
+ * Phase 2: Consolidates ActionContext and EnhancedActionContext into one interface
+ */
+export interface ActionContext {
+    /**
+     * Read-only access to the world model
+     */
+    readonly world: WorldModel;
+    /**
+     * The player entity
+     */
+    readonly player: IFEntity;
+    /**
+     * The player's current location
+     */
+    readonly currentLocation: IFEntity;
+    /**
+     * The validated command being executed
+     */
+    readonly command: ValidatedCommand;
+    /**
+     * The scope resolver for determining what's perceivable
+     */
+    readonly scopeResolver: ScopeResolver;
+    /**
+     * Check if an entity is visible to the player
+     */
+    canSee(entity: IFEntity): boolean;
+    /**
+     * Check if an entity is physically reachable by the player
+     */
+    canReach(entity: IFEntity): boolean;
+    /**
+     * Check if an entity can be taken by the player
+     */
+    canTake(entity: IFEntity): boolean;
+    /**
+     * Check if an entity is in scope for the player
+     */
+    isInScope(entity: IFEntity): boolean;
+    /**
+     * Get all entities visible to the player
+     */
+    getVisible(): IFEntity[];
+    /**
+     * Get all entities in scope for the player
+     */
+    getInScope(): IFEntity[];
+    /**
+     * Get the scope level for an entity.
+     *
+     * Returns the current scope level of the entity relative to the player,
+     * using the ScopeResolver. This is the low-level method for custom
+     * scope logic.
+     *
+     * @param entity The entity to check
+     * @returns The scope level (UNAWARE through CARRIED)
+     *
+     * @example
+     * const scope = context.getEntityScope(target);
+     * if (scope >= ScopeLevel.VISIBLE) {
+     *   // Can see it, maybe interact with it
+     * }
+     */
+    getEntityScope(entity: IFEntity): ScopeLevel;
+    /**
+     * Get the scope level for an entity in a command slot.
+     *
+     * Convenience method that gets the entity from the command slot
+     * and returns its scope level.
+     *
+     * @param slot The slot name ('target', 'item', 'container', etc.)
+     * @returns The scope level, or UNAWARE if no entity in slot
+     *
+     * @example
+     * const scope = context.getSlotScope('target');
+     */
+    getSlotScope(slot: string): ScopeLevel;
+    /**
+     * Check if an entity meets a required scope level.
+     *
+     * This is the high-level helper for scope validation in actions.
+     * Returns a result that can be used directly in validate():
+     *
+     * @param entity The entity to check
+     * @param required The minimum scope level required
+     * @returns ScopeCheckResult with ok=true or error details
+     *
+     * @example
+     * // Simple scope check in validate()
+     * const scopeCheck = context.requireScope(target, ScopeLevel.REACHABLE);
+     * if (!scopeCheck.ok) return scopeCheck.error;
+     *
+     * @example
+     * // Dynamic scope based on entity traits
+     * const effectiveScope = target.has(TraitType.REMOTE_CONTROLLABLE)
+     *   ? ScopeLevel.VISIBLE
+     *   : ScopeLevel.REACHABLE;
+     * const scopeCheck = context.requireScope(target, effectiveScope);
+     * if (!scopeCheck.ok) return scopeCheck.error;
+     */
+    requireScope(entity: IFEntity, required: ScopeLevel): ScopeCheckResult;
+    /**
+     * Check if a command slot entity meets a required scope level.
+     *
+     * Convenience method that combines getting the entity from a slot
+     * and checking its scope. Returns an error if no entity in slot
+     * or if scope check fails.
+     *
+     * @param slot The slot name ('target', 'item', 'container', etc.)
+     * @param required The minimum scope level required
+     * @returns ScopeCheckResult with ok=true or error details
+     *
+     * @example
+     * const scopeCheck = context.requireSlotScope('target', ScopeLevel.REACHABLE);
+     * if (!scopeCheck.ok) return scopeCheck.error;
+     */
+    requireSlotScope(slot: string, required: ScopeLevel): ScopeCheckResult;
+    /**
+     * Check if an entity is carried, attempting an implicit take if needed.
+     *
+     * This is the preferred method for actions that require a CARRIED item
+     * but should support implicit takes (e.g., "put apple in box" when apple
+     * is on the ground).
+     *
+     * Logic:
+     * 1. If entity is already carried → return success
+     * 2. If entity is reachable and takeable → attempt implicit take
+     * 3. If implicit take succeeds → return success with events to prepend
+     * 4. If implicit take fails → return the take's error
+     * 5. If entity is not reachable → return scope error
+     *
+     * The implicit take events should be prepended to the action's report
+     * events via sharedData.implicitTakeEvents.
+     *
+     * @param entity The entity that needs to be carried
+     * @returns ImplicitTakeResult with ok=true or error details
+     *
+     * @example
+     * // In validate():
+     * const carryCheck = context.requireCarriedOrImplicitTake(item);
+     * if (!carryCheck.ok) return carryCheck.error;
+     * // Events stored in sharedData.implicitTakeEvents for report phase
+     *
+     * // In report():
+     * const events: ISemanticEvent[] = [];
+     * if (context.sharedData.implicitTakeEvents) {
+     *   events.push(...context.sharedData.implicitTakeEvents);
+     * }
+     * // ... add main action events
+     */
+    requireCarriedOrImplicitTake(entity: IFEntity): ImplicitTakeResult;
+    /**
+     * Shared data store for passing information between action phases.
+     *
+     * This property enables clean data passing from the execute phase to the report phase,
+     * eliminating the need for context pollution patterns like `(context as any)._previousLocation`.
+     *
+     * Data stored here during execute() is available in report() for creating rich events
+     * with full context about what changed during the action.
+     *
+     * @deprecated Prefer using ValidationResult.data for passing data from validate()
+     * to later phases. sharedData is still useful for passing data between execute()
+     * and report() phases, but validate() discoveries should go in ValidationResult.data.
+     *
+     * @example
+     * // In execute() phase - capture context before mutations
+     * context.sharedData.previousLocation = context.world.getLocation(item.id);
+     * context.sharedData.wasWorn = item.has(TraitType.WEARABLE) && item.wearable.worn;
+     *
+     * // In report() phase - access captured data
+     * const { previousLocation, wasWorn } = context.sharedData;
+     * if (wasWorn) {
+     *   events.push(context.event('if.event.removed', { item: item.name }));
+     * }
+     */
+    sharedData: Record<string, any>;
+    /**
+     * The validation result from the validate() phase.
+     *
+     * This is set by the engine after validate() returns and before calling
+     * execute() or blocked(). Actions can access data passed from validate()
+     * via validationResult.data.
+     *
+     * @example
+     * // In validate() - return discovered data
+     * return { valid: true, data: { trait, behavior, entity } };
+     *
+     * // In execute() or report() - access the data
+     * const { behavior, entity } = context.validationResult!.data!;
+     * behavior.execute(entity, context.world, context.player.id);
+     */
+    validationResult?: ValidationResult;
+    /**
+     * The action being executed (for message resolution)
+     */
+    readonly action: Action;
+    /**
+     * Create an event with automatic entity injection and metadata enrichment
+     *
+     * @param type Event type (e.g., 'if.event.taken', 'action.success', 'action.error')
+     * @param data Event data - will be enriched with entities and metadata
+     * @returns A properly formatted ISemanticEvent
+     *
+     * @example
+     * // Simple error
+     * return [context.event('action.error', {
+     *   actionId: context.action.id,
+     *   messageId: 'no_target'
+     * })]
+     *
+     * @example
+     * // Success with typed data
+     * const eventData: TakenEventData = { item: noun.name, messageId: 'taken' }
+     * return [
+     *   context.event('if.event.taken', eventData)
+     * ]
+     */
+    event(type: string, data: any): ISemanticEvent;
+}
+/**
+ * @deprecated Use ActionContext instead. Will be removed in Phase 2.2.
+ *
+ * Enhanced action context with helper methods for event creation
+ *
+ * This interface is now redundant as ActionContext includes all capabilities.
+ * Kept temporarily for backward compatibility during migration.
+ */
+export interface EnhancedActionContext extends ActionContext {
+}
+/**
+ * Result from action validation
+ *
+ * Used to determine if an action can be executed and provide
+ * specific error information if not.
+ */
+export interface ValidationResult {
+    /**
+     * Whether the action can be executed
+     */
+    valid: boolean;
+    /**
+     * Error code if validation failed
+     * Used to look up appropriate error messages
+     */
+    error?: string;
+    /**
+     * Additional context for error messages
+     */
+    params?: Record<string, any>;
+    /**
+     * Optional custom message ID to use instead of default
+     */
+    messageId?: string;
+    /**
+     * Data to pass from validate() to execute() and report() phases.
+     *
+     * This enables clean data flow without using sharedData mutations.
+     * When validate() discovers entities, traits, or behaviors, it can
+     * return them in data for later phases to use.
+     *
+     * @example
+     * // In validate() - return discovered data
+     * return { valid: true, data: { trait, behavior, entity } };
+     *
+     * // In execute/report() - access via context.validationResult
+     * const { behavior, entity } = context.validationResult!.data!;
+     */
+    data?: Record<string, any>;
+}
+/**
+ * Unified action interface
+ *
+ * Actions define patterns, messages, and execution logic together.
+ * They follow a three-phase pattern: validate, execute, then report.
+ *
+ * Phase 3.5 Update (Complete Event Ownership):
+ * - validate(): Check if action can proceed (returns ValidationResult)
+ * - execute(): Perform mutations only (returns void or ISemanticEvent[] for compatibility)
+ * - report(): Generate ALL events including errors (owns complete event lifecycle)
+ *
+ * The report() method is ALWAYS called and is responsible for:
+ * - Creating success events with captured entity snapshots
+ * - Creating error events based on validation or execution results
+ * - Ensuring all events have complete context and data
+ *
+ * During migration, actions can implement either pattern:
+ * - Old: validate + execute (returns events) - CommandExecutor creates error events
+ * - New: validate + execute (void) + report - Action creates ALL events
+ */
+/**
+ * Scope requirements for action slots.
+ *
+ * Maps slot names (e.g., 'target', 'item', 'recipient') to their
+ * required scope level. This documents the default requirements
+ * and can be used by the parser for entity resolution hints.
+ *
+ * Actions can override these dynamically in validate() using
+ * context.requireScope() for more complex scenarios.
+ *
+ * @example
+ * // Taking requires the target to be reachable
+ * defaultScope: { target: ScopeLevel.REACHABLE }
+ *
+ * @example
+ * // Giving requires item carried and recipient visible
+ * defaultScope: {
+ *   item: ScopeLevel.CARRIED,
+ *   recipient: ScopeLevel.VISIBLE
+ * }
+ */
+export type ActionScopeRequirements = Record<string, ScopeLevel>;
+export interface Action {
+    /**
+     * Unique identifier for this action
+     */
+    id: string;
+    /**
+     * Default scope requirements for this action's slots.
+     *
+     * Documents what scope level each slot requires by default.
+     * Used for:
+     * - Parser hints during entity resolution
+     * - Default scope validation in validate()
+     * - Documentation of action requirements
+     *
+     * Actions can perform dynamic scope checking in validate() using
+     * context.requireScope() for complex scenarios where requirements
+     * depend on entity traits or world state.
+     *
+     * @example
+     * defaultScope: { target: ScopeLevel.REACHABLE }
+     *
+     * @example
+     * defaultScope: {
+     *   item: ScopeLevel.CARRIED,
+     *   container: ScopeLevel.REACHABLE
+     * }
+     */
+    defaultScope?: ActionScopeRequirements;
+    /**
+     * List of message IDs this action requires
+     * Used for documentation and validation
+     * Example: ['taken', 'already_have', 'cant_take']
+     */
+    requiredMessages?: string[];
+    /**
+     * Validate whether this action can be executed in the current context
+     *
+     * This method should check:
+     * - Entity requirements (exists, has required traits)
+     * - State preconditions (using behavior validation methods)
+     * - Any action-specific constraints
+     *
+     * @param context Unified action context with helper methods
+     * @returns Validation result indicating if action can proceed
+     */
+    validate(context: ActionContext): ValidationResult;
+    /**
+     * Execute the action (mutations only in new pattern)
+     *
+     * This method is only called if validate() returned { valid: true }.
+     *
+     * Old pattern: Returns events describing what happened
+     * New pattern: Returns void, only performs mutations
+     *
+     * @param context Unified action context with helper methods
+     * @returns Array of events (old pattern) or void (new pattern)
+     */
+    execute(context: ActionContext): ISemanticEvent[] | void;
+    /**
+     * Generate success events (four-phase pattern)
+     *
+     * This method is ONLY called when validation passes and execute() succeeds.
+     * It is responsible for creating success events with captured entity snapshots.
+     *
+     * NOTE: This will become required once all actions are migrated to the new pattern.
+     * For now it's optional to maintain backward compatibility with unmigrated actions.
+     *
+     * @param context Unified action context
+     * @returns Array of success events with captured state data
+     */
+    report?(context: ActionContext): ISemanticEvent[];
+    /**
+     * Generate blocked events when validation fails (four-phase pattern)
+     *
+     * This method is called when validate() returns { valid: false }.
+     * It creates appropriate error/blocked events based on the validation result.
+     *
+     * Each action owns its own blocked messages and can customize the response.
+     * A default implementation generates a standard 'action.blocked' event.
+     *
+     * NOTE: This will become required once all actions are migrated to the new pattern.
+     * For now it's optional to maintain backward compatibility with unmigrated actions.
+     *
+     * @param context Unified action context
+     * @param result The validation result containing error info
+     * @returns Array of blocked/error events
+     */
+    blocked?(context: ActionContext, result: ValidationResult): ISemanticEvent[];
+    /**
+     * @deprecated Use validate() instead. This will be removed after refactoring.
+     * Optional method to validate if this action can handle the command
+     * By default, pattern matching is sufficient
+     */
+    canExecute?(context: ActionContext): boolean;
+    /**
+     * Message ID for the action description (for help/documentation)
+     * The language provider should have this message
+     */
+    descriptionMessageId?: string;
+    /**
+     * Message ID for example commands (for help/documentation)
+     * The language provider should format this as a list
+     */
+    examplesMessageId?: string;
+    /**
+     * Action group (for organizing related actions)
+     */
+    group?: string;
+    /**
+     * Priority for pattern matching (higher = preferred)
+     * Default is 0
+     */
+    priority?: number;
+    /**
+     * Requirements the target must meet for this action to succeed.
+     *
+     * Used by implicit inference to find a valid alternative when the
+     * player uses a pronoun that resolved to something that doesn't
+     * meet the requirements.
+     *
+     * Inference ONLY triggers when pronouns are used ("read it"), not
+     * when the player explicitly names an entity ("read mailbox").
+     *
+     * @example
+     * // Reading requires ReadableTrait
+     * targetRequirements: {
+     *   trait: 'ReadableTrait',
+     *   description: 'readable'
+     * }
+     *
+     * @example
+     * // Opening requires OpenableTrait and NOT already open
+     * targetRequirements: {
+     *   trait: 'OpenableTrait',
+     *   condition: 'not_open',
+     *   description: 'openable'
+     * }
+     */
+    targetRequirements?: {
+        /** Trait the target must have (e.g., 'ReadableTrait', 'OpenableTrait') */
+        trait?: string;
+        /** Additional condition (e.g., 'not_open', 'not_locked') */
+        condition?: string;
+        /** Human-readable description for messages (e.g., 'readable', 'openable') */
+        description: string;
+    };
+    /**
+     * Whether the target must be held (in inventory) for this action.
+     *
+     * When true and the target isn't held, an implicit take will be
+     * attempted before executing the main action.
+     *
+     * Unlike inference, implicit take works for BOTH pronouns and
+     * explicit nouns ("read leaflet" still auto-takes the leaflet).
+     *
+     * @example
+     * // Reading requires holding the item
+     * requiresHolding: true
+     */
+    requiresHolding?: boolean;
+    /**
+     * Whether to allow implicit inference for this action.
+     *
+     * When true (default), if the target doesn't meet targetRequirements
+     * and a pronoun was used, the system will try to find a valid
+     * alternative in scope.
+     *
+     * Set to false to disable inference for this action.
+     */
+    allowImplicitInference?: boolean;
+    /**
+     * Whether to allow implicit take for this action.
+     *
+     * When true (default if requiresHolding is true), if the target
+     * isn't held, the system will try to take it first.
+     *
+     * Set to false to disable implicit take even if requiresHolding is true.
+     */
+    allowImplicitTake?: boolean;
+}
+/**
+ * Text event structure
+ *
+ * Standard structure for events that produce text output
+ */
+export interface TextEvent extends ISemanticEvent {
+    type: 'text' | 'action.success' | 'action.error' | 'game.message';
+    data: {
+        /**
+         * Message ID to look up
+         */
+        messageId: string;
+        /**
+         * Parameters for message formatting
+         */
+        params?: Record<string, any>;
+        /**
+         * Optional fallback text if message ID not found
+         */
+        fallback?: string;
+        /**
+         * Optional metadata
+         */
+        metadata?: Record<string, any>;
+    };
+}
+/**
+ * Action registry interface
+ */
+export interface ActionRegistry {
+    /**
+     * Register an action
+     */
+    register(action: Action): void;
+    /**
+     * Register multiple actions
+     */
+    registerMany(actions: Action[]): void;
+    /**
+     * Get an action by ID
+     */
+    get(actionId: string): Action | undefined;
+    /**
+     * Get all registered actions
+     */
+    getAll(): Action[];
+    /**
+     * Check if an action is registered
+     */
+    has(actionId: string): boolean;
+    /**
+     * Find actions by pattern
+     */
+    findByPattern(pattern: string): Action[];
+    /**
+     * Get actions by group
+     */
+    getByGroup(group: string): Action[];
+    /**
+     * Register messages for an action
+     */
+    registerMessages(actionId: string, messages: Record<string, string>): void;
+}
+/**
+ * Message registry interface
+ */
+export interface MessageRegistry {
+    /**
+     * Register messages
+     */
+    register(messages: Record<string, string>): void;
+    /**
+     * Register messages with a namespace
+     */
+    registerNamespaced(namespace: string, messages: Record<string, string>): void;
+    /**
+     * Get a message by ID
+     */
+    getMessage(id: string, params?: Record<string, any>): string;
+    /**
+     * Check if a message exists
+     */
+    hasMessage(id: string): boolean;
+    /**
+     * Get all messages in a namespace
+     */
+    getNamespace(namespace: string): Record<string, string>;
+    /**
+     * Override a message
+     */
+    override(id: string, message: string): void;
+}
+/**
+ * Helper type for action definitions
+ */
+export type ActionDefinition = Omit<Action, 'execute'> & {
+    execute: (context: ActionContext) => ISemanticEvent[];
+};
+/**
+ * Standard message namespaces
+ */
+export declare const MessageNamespaces: {
+    readonly SYSTEM: "if.system";
+    readonly ACTION: "if.action";
+    readonly ERROR: "if.error";
+    readonly GAME: "if.game";
+    readonly STORY: "story";
+    readonly EXTENSION: "ext";
+};
+/**
+ * Standard event types
+ */
+export declare const EventTypes: {
+    readonly TEXT: "text";
+    readonly ACTION_SUCCESS: "action.success";
+    readonly ACTION_ERROR: "action.error";
+    readonly ACTION_FAILED: "action.failed";
+    readonly GAME_MESSAGE: "game.message";
+    readonly SYSTEM_MESSAGE: "system.message";
+};
+//# sourceMappingURL=enhanced-types.d.ts.map

package/actions/enhanced-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhanced-types.d.ts","sourceRoot":"","sources":["../../../../../../repos/sharpee/packages/stdlib/src/actions/enhanced-types.ts"],"names":[],"mappings":"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"}