@sharpee/stdlib 0.9.65-beta → 0.9.67-beta

package/dist-npm/actions/enhanced-types.d.ts

@@ -1,697 +0,0 @@
-/**
- * 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/dist-npm/src/index";
-import { IFEntity, WorldModel } from "../../../world-model/dist-npm/src/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 }
-     * return [
-     *   context.event('if.event.taken', eventData),
-     *   context.event('action.success', {
-     *     actionId: context.action.id,
-     *     messageId: 'taken',
-     *     params: 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/dist-npm/actions/enhanced-types.d.ts.map

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