@sharpee/ext-testing 0.9.62-beta → 0.9.66-beta

package/src/checkpoints/serializer.ts

@@ -1,121 +0,0 @@
-/**
- * Checkpoint Serializer
- *
- * Handles serialization and deserialization of game state for checkpoints.
- * Captures world model state and scheduler state (daemons, fuses).
- */
-
-import type { WorldModel } from '@sharpee/world-model';
-import type { CheckpointData, SerializedDaemon, SerializedFuse } from '../types.js';
-
-/**
- * Serialize current game state to checkpoint data
- */
-export function serializeCheckpoint(
-  world: WorldModel,
-  name?: string
-): CheckpointData {
-  const player = world.getPlayer();
-  const playerLocation = player ? world.getLocation(player.id) : undefined;
-
-  // Get world state via WorldModel.toJSON()
-  const worldState = world.toJSON();
-
-  // TODO: Get scheduler state when scheduler API is available
-  // For now, scheduler state is omitted
-  const schedulerState = undefined;
-
-  const checkpoint: CheckpointData = {
-    version: '1.0.0',
-    timestamp: Date.now(),
-    metadata: {
-      name,
-      turn: getTurnNumber(world),
-      location: playerLocation,
-    },
-    worldState,
-    schedulerState,
-  };
-
-  return checkpoint;
-}
-
-/**
- * Deserialize checkpoint data and restore game state
- */
-export function deserializeCheckpoint(
-  checkpoint: CheckpointData,
-  world: WorldModel
-): void {
-  // Validate version
-  if (checkpoint.version !== '1.0.0') {
-    throw new Error(`Unsupported checkpoint version: ${checkpoint.version}`);
-  }
-
-  // Restore world state via WorldModel.loadJSON()
-  world.loadJSON(checkpoint.worldState);
-
-  // TODO: Restore scheduler state when scheduler API is available
-  if (checkpoint.schedulerState) {
-    restoreSchedulerState(world, checkpoint.schedulerState);
-  }
-}
-
-/**
- * Get current turn number from world
- */
-function getTurnNumber(world: WorldModel): number {
-  // Try to get turn from world metadata or state
-  // This may need adjustment based on actual WorldModel API
-  try {
-    const state = JSON.parse(world.toJSON());
-    return state.turn ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Restore scheduler state (daemons and fuses)
- */
-function restoreSchedulerState(
-  world: WorldModel,
-  state: {
-    turn: number;
-    daemons: SerializedDaemon[];
-    fuses: SerializedFuse[];
-  }
-): void {
-  // TODO: Implement when scheduler serialization API is available
-  // This will need access to the engine's scheduler service
-  console.warn('Scheduler state restoration not yet implemented');
-}
-
-/**
- * Validate checkpoint data structure
- */
-export function validateCheckpoint(data: unknown): data is CheckpointData {
-  if (!data || typeof data !== 'object') {
-    return false;
-  }
-
-  const checkpoint = data as Partial<CheckpointData>;
-
-  if (checkpoint.version !== '1.0.0') {
-    return false;
-  }
-
-  if (typeof checkpoint.timestamp !== 'number') {
-    return false;
-  }
-
-  if (!checkpoint.metadata || typeof checkpoint.metadata !== 'object') {
-    return false;
-  }
-
-  if (typeof checkpoint.worldState !== 'string') {
-    return false;
-  }
-
-  return true;
-}

package/src/checkpoints/store.ts

@@ -1,188 +0,0 @@
-/**
- * Checkpoint Store
- *
- * File-based storage for checkpoints.
- * Supports both Node.js (filesystem) and browser (localStorage) environments.
- */
-
-import type { CheckpointData, CheckpointStore } from '../types.js';
-import { validateCheckpoint } from './serializer.js';
-
-/**
- * Create a file-based checkpoint store (Node.js)
- */
-export function createFileStore(directory: string): CheckpointStore {
-  // Dynamic import for Node.js fs module
-  let fs: typeof import('fs') | undefined;
-  let path: typeof import('path') | undefined;
-
-  const ensureFs = async () => {
-    if (!fs) {
-      fs = await import('fs');
-      path = await import('path');
-    }
-    return { fs, path: path! };
-  };
-
-  const getFilePath = (pathModule: typeof import('path'), name: string): string => {
-    return pathModule.join(directory, `${name}.json`);
-  };
-
-  const store: CheckpointStore = {
-    async save(name: string, data: CheckpointData): Promise<void> {
-      const { fs, path } = await ensureFs();
-
-      // Ensure directory exists
-      if (!fs.existsSync(directory)) {
-        fs.mkdirSync(directory, { recursive: true });
-      }
-
-      const filePath = getFilePath(path, name);
-      const json = JSON.stringify(data, null, 2);
-      fs.writeFileSync(filePath, json, 'utf-8');
-    },
-
-    async load(name: string): Promise<CheckpointData | undefined> {
-      const { fs, path } = await ensureFs();
-
-      const filePath = getFilePath(path, name);
-
-      if (!fs.existsSync(filePath)) {
-        return undefined;
-      }
-
-      try {
-        const json = fs.readFileSync(filePath, 'utf-8');
-        const data = JSON.parse(json);
-
-        if (!validateCheckpoint(data)) {
-          console.warn(`Invalid checkpoint data in ${filePath}`);
-          return undefined;
-        }
-
-        return data;
-      } catch (error) {
-        console.error(`Failed to load checkpoint ${name}:`, error);
-        return undefined;
-      }
-    },
-
-    async list(): Promise<string[]> {
-      const { fs } = await ensureFs();
-
-      if (!fs.existsSync(directory)) {
-        return [];
-      }
-
-      const files = fs.readdirSync(directory);
-      return files
-        .filter((f) => f.endsWith('.json'))
-        .map((f) => f.replace(/\.json$/, ''));
-    },
-
-    async delete(name: string): Promise<boolean> {
-      const { fs, path } = await ensureFs();
-
-      const filePath = getFilePath(path, name);
-
-      if (!fs.existsSync(filePath)) {
-        return false;
-      }
-
-      fs.unlinkSync(filePath);
-      return true;
-    },
-
-    async exists(name: string): Promise<boolean> {
-      const { fs, path } = await ensureFs();
-
-      const filePath = getFilePath(path, name);
-      return fs.existsSync(filePath);
-    },
-  };
-
-  return store;
-}
-
-/**
- * Create a memory-based checkpoint store (for testing or browser)
- */
-export function createMemoryStore(): CheckpointStore {
-  const checkpoints = new Map<string, CheckpointData>();
-
-  return {
-    async save(name: string, data: CheckpointData): Promise<void> {
-      checkpoints.set(name, data);
-    },
-
-    async load(name: string): Promise<CheckpointData | undefined> {
-      return checkpoints.get(name);
-    },
-
-    async list(): Promise<string[]> {
-      return Array.from(checkpoints.keys());
-    },
-
-    async delete(name: string): Promise<boolean> {
-      return checkpoints.delete(name);
-    },
-
-    async exists(name: string): Promise<boolean> {
-      return checkpoints.has(name);
-    },
-  };
-}
-
-/**
- * Create a localStorage-based checkpoint store (browser)
- */
-export function createLocalStorageStore(prefix: string = 'sharpee-checkpoint-'): CheckpointStore {
-  const getKey = (name: string) => `${prefix}${name}`;
-
-  return {
-    async save(name: string, data: CheckpointData): Promise<void> {
-      const json = JSON.stringify(data);
-      localStorage.setItem(getKey(name), json);
-    },
-
-    async load(name: string): Promise<CheckpointData | undefined> {
-      const json = localStorage.getItem(getKey(name));
-      if (!json) return undefined;
-
-      try {
-        const data = JSON.parse(json);
-        if (!validateCheckpoint(data)) {
-          console.warn(`Invalid checkpoint data for ${name}`);
-          return undefined;
-        }
-        return data;
-      } catch {
-        return undefined;
-      }
-    },
-
-    async list(): Promise<string[]> {
-      const names: string[] = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key?.startsWith(prefix)) {
-          names.push(key.slice(prefix.length));
-        }
-      }
-      return names;
-    },
-
-    async delete(name: string): Promise<boolean> {
-      const key = getKey(name);
-      if (localStorage.getItem(key) === null) {
-        return false;
-      }
-      localStorage.removeItem(key);
-      return true;
-    },
-
-    async exists(name: string): Promise<boolean> {
-      return localStorage.getItem(getKey(name)) !== null;
-    },
-  };
-}

package/src/commands/index.ts

@@ -1 +0,0 @@
-export { createCommandRegistry, parseGdtInput, parseTestInput } from './registry.js';

package/src/commands/registry.ts

@@ -1,81 +0,0 @@
-/**
- * Command Registry
- *
- * Central registry for debug and test commands.
- * Commands can be looked up by GDT code or test syntax.
- */
-
-import type { DebugCommand, CommandCategory, CommandRegistry } from '../types.js';
-
-/**
- * Create a new command registry
- */
-export function createCommandRegistry(): CommandRegistry {
-  const byCode = new Map<string, DebugCommand>();
-  const byTestSyntax = new Map<string, DebugCommand>();
-  const allCommands: DebugCommand[] = [];
-
-  const registry: CommandRegistry = {
-    register(command: DebugCommand): void {
-      // Register by code (uppercase for case-insensitive lookup)
-      byCode.set(command.code.toUpperCase(), command);
-
-      // Register by test syntax if provided
-      if (command.testSyntax) {
-        byTestSyntax.set(command.testSyntax.toLowerCase(), command);
-      }
-
-      allCommands.push(command);
-    },
-
-    getByCode(code: string): DebugCommand | undefined {
-      return byCode.get(code.toUpperCase());
-    },
-
-    getByTestSyntax(syntax: string): DebugCommand | undefined {
-      return byTestSyntax.get(syntax.toLowerCase());
-    },
-
-    getAll(): DebugCommand[] {
-      return [...allCommands];
-    },
-
-    getByCategory(category: CommandCategory): DebugCommand[] {
-      return allCommands.filter((cmd) => cmd.category === category);
-    },
-  };
-
-  return registry;
-}
-
-/**
- * Parse a GDT-style command input
- * Format: "CODE arg1 arg2" or just "CODE"
- */
-export function parseGdtInput(input: string): { code: string; args: string[] } {
-  const trimmed = input.trim();
-  const parts = trimmed.split(/\s+/);
-  const code = parts[0] || '';
-  const args = parts.slice(1);
-
-  return { code: code.toUpperCase(), args };
-}
-
-/**
- * Parse a test command input
- * Format: "$command arg1 arg2" or just "$command"
- */
-export function parseTestInput(input: string): { syntax: string; args: string[] } | undefined {
-  const trimmed = input.trim();
-
-  if (!trimmed.startsWith('$')) {
-    return undefined;
-  }
-
-  const withoutPrefix = trimmed.slice(1);
-  const parts = withoutPrefix.split(/\s+/);
-  const syntax = parts[0] || '';
-  const args = parts.slice(1);
-
-  return { syntax: syntax.toLowerCase(), args };
-}

package/src/context/debug-context.ts

@@ -1,209 +0,0 @@
-/**
- * Debug Context Implementation
- *
- * Provides a unified context for debug and test commands to interact with the game world.
- * Generalizes the pattern from Dungeo's GDTContext.
- */
-
-import type { WorldModel, IFEntity } from '@sharpee/world-model';
-import { AuthorModel } from '@sharpee/world-model';
-import type { DebugContext } from '../types.js';
-
-/**
- * Create a debug context for the given world
- */
-export function createDebugContext(world: WorldModel): DebugContext {
-  // Create AuthorModel for bypassing game rules
-  const author = new AuthorModel(world.getDataStore(), world);
-
-  // Debug flags storage
-  const flags = new Map<string, boolean>();
-
-  // Find player entity
-  const player = world.getPlayer();
-  if (!player) {
-    throw new Error('Cannot create debug context: no player entity found');
-  }
-
-  const context: DebugContext = {
-    world,
-    author,
-    player,
-    flags,
-
-    // ========================================================================
-    // Entity Lookup
-    // ========================================================================
-
-    findEntity(idOrName: string): IFEntity | undefined {
-      // Try exact ID match first
-      const byId = world.getEntity(idOrName);
-      if (byId) return byId;
-
-      // Normalize search term: lowercase, convert hyphens to spaces
-      const searchLower = idOrName.toLowerCase();
-      const searchNormalized = searchLower.replace(/-/g, ' ');
-      const allEntities = world.getAllEntities();
-
-      // Exact name match (with normalized search)
-      const exactMatch = allEntities.find(
-        (e) => e.name?.toLowerCase() === searchNormalized ||
-               e.name?.toLowerCase() === searchLower
-      );
-      if (exactMatch) return exactMatch;
-
-      // Partial name match (with normalized search)
-      const partialMatch = allEntities.find(
-        (e) => e.name?.toLowerCase().includes(searchNormalized) ||
-               e.name?.toLowerCase().includes(searchLower)
-      );
-      if (partialMatch) return partialMatch;
-
-      // ID contains search term
-      const idMatch = allEntities.find(
-        (e) => e.id.toLowerCase().includes(searchLower)
-      );
-      return idMatch;
-    },
-
-    findRoom(idOrName: string): IFEntity | undefined {
-      const entity = context.findEntity(idOrName);
-      if (entity && entity.type === 'room') {
-        return entity;
-      }
-
-      // Search only rooms
-      const searchLower = idOrName.toLowerCase();
-      const rooms = world.getAllEntities().filter((e) => e.type === 'room');
-
-      const exactMatch = rooms.find(
-        (r) => r.name?.toLowerCase() === searchLower
-      );
-      if (exactMatch) return exactMatch;
-
-      const partialMatch = rooms.find(
-        (r) => r.name?.toLowerCase().includes(searchLower) ||
-               r.id.toLowerCase().includes(searchLower)
-      );
-      return partialMatch;
-    },
-
-    findEntities(predicate: (entity: IFEntity) => boolean): IFEntity[] {
-      return world.getAllEntities().filter(predicate);
-    },
-
-    // ========================================================================
-    // Location Queries
-    // ========================================================================
-
-    getPlayerLocation(): IFEntity | undefined {
-      const locationId = world.getLocation(player.id);
-      if (!locationId) return undefined;
-      return world.getEntity(locationId);
-    },
-
-    getInventory(): IFEntity[] {
-      return world.getContents(player.id);
-    },
-
-    getContents(locationId: string): IFEntity[] {
-      return world.getContents(locationId);
-    },
-
-    // ========================================================================
-    // Mutations (bypass game rules via AuthorModel)
-    // ========================================================================
-
-    teleportPlayer(roomId: string): boolean {
-      const room = context.findRoom(roomId);
-      if (!room) return false;
-
-      author.moveEntity(player.id, room.id);
-      return true;
-    },
-
-    moveObject(objectId: string, locationId: string): boolean {
-      const object = context.findEntity(objectId);
-      const location = context.findEntity(locationId);
-
-      if (!object || !location) return false;
-
-      author.moveEntity(object.id, location.id);
-      return true;
-    },
-
-    takeObject(objectId: string): boolean {
-      const object = context.findEntity(objectId);
-      if (!object) return false;
-
-      author.moveEntity(object.id, player.id);
-      return true;
-    },
-
-    removeObject(objectId: string): boolean {
-      const object = context.findEntity(objectId);
-      if (!object) return false;
-
-      // Move to limbo (null location)
-      author.moveEntity(object.id, 'limbo');
-      return true;
-    },
-
-    spawnObject(objectId: string, locationId: string): boolean {
-      const object = context.findEntity(objectId);
-      const location = context.findEntity(locationId);
-
-      if (!object || !location) return false;
-
-      author.moveEntity(object.id, location.id);
-      return true;
-    },
-
-    // ========================================================================
-    // Flag Operations
-    // ========================================================================
-
-    setFlag(name: string, value: boolean): void {
-      flags.set(name, value);
-    },
-
-    getFlag(name: string): boolean {
-      return flags.get(name) ?? false;
-    },
-  };
-
-  return context;
-}
-
-/**
- * Format entity for debug display
- */
-export function formatEntity(entity: IFEntity): string {
-  const traitTypes = entity.traits
-    ? Array.from(entity.traits.values()).map((t) => t.type.split('.').pop()).join(', ')
-    : 'none';
-  return `${entity.id} (${entity.name || 'unnamed'}) [${traitTypes}]`;
-}
-
-/**
- * Format location chain for an entity
- */
-export function formatLocationChain(entity: IFEntity, world: WorldModel): string {
-  const chain: string[] = [entity.id];
-  let current = entity;
-  let depth = 0;
-
-  while (depth < 10) {
-    const locationId = world.getLocation(current.id);
-    if (!locationId) break;
-
-    chain.push(locationId);
-    const location = world.getEntity(locationId);
-    if (!location) break;
-
-    current = location;
-    depth++;
-  }
-
-  return chain.join(' -> ');
-}

package/src/context/index.ts

@@ -1 +0,0 @@
-export { createDebugContext, formatEntity, formatLocationChain } from './debug-context.js';