@forbocai/test-game 0.6.0

package/dist/chunk-NNRCMKGA.mjs

@@ -0,0 +1,694 @@
+// src/lib/coverage.ts
+var REQUIRED_GROUPS = [
+  "status",
+  "npc_lifecycle",
+  "npc_process_chat",
+  "memory_list",
+  "memory_recall",
+  "memory_store",
+  "memory_clear",
+  "memory_export",
+  "bridge_rules",
+  "bridge_validate",
+  "bridge_preset",
+  "soul_export",
+  "soul_import",
+  "soul_list",
+  "soul_chat",
+  "ghost_lifecycle",
+  "cortex_init"
+];
+
+// src/game.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/features/autoplay/slices/harnessSlice.ts
+import { createSlice } from "@reduxjs/toolkit";
+var initialState = {
+  covered: {}
+};
+var harnessSlice = createSlice({
+  name: "harness",
+  initialState,
+  reducers: {
+    markCovered: (state, action) => {
+      state.covered[action.payload] = true;
+    },
+    resetCoverage: (state) => {
+      state.covered = {};
+    }
+  }
+});
+var harnessReducer = harnessSlice.reducer;
+var harnessActions = harnessSlice.actions;
+var selectMissingGroups = (covered) => REQUIRED_GROUPS.filter((g) => !covered[g]);
+
+// src/features/mechanics/slices/bridgeSlice.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {
+  maxJumpForce: 500,
+  maxMoveDistance: 2,
+  activePreset: "default"
+};
+var bridgeSlice = createSlice2({
+  name: "bridge",
+  initialState: initialState2,
+  reducers: {
+    setBridgeRules: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    loadBridgePreset: (state, action) => {
+      state.activePreset = action.payload;
+      if (action.payload === "social") {
+        state.maxMoveDistance = 1;
+      }
+      if (action.payload === "default") {
+        state.maxMoveDistance = 2;
+      }
+    }
+  }
+});
+var bridgeReducer = bridgeSlice.reducer;
+var bridgeActions = bridgeSlice.actions;
+var validateJump = (rules, force) => {
+  if (force > rules.maxJumpForce) {
+    return { valid: false, reason: `Jump force ${force} exceeds ${rules.maxJumpForce}` };
+  }
+  return { valid: true };
+};
+var capMoveDistance = (rules, requestedDistance) => ({
+  allowedDistance: Math.min(requestedDistance, rules.maxMoveDistance),
+  capped: requestedDistance > rules.maxMoveDistance
+});
+
+// src/features/mechanics/slices/socialSlice.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {};
+var socialSlice = createSlice3({
+  name: "social",
+  initialState: initialState3,
+  reducers: {
+    setDialogue: (state, action) => {
+      state.activeDialogue = action.payload;
+    },
+    setTradeOffer: (state, action) => {
+      state.activeTrade = action.payload;
+    },
+    clearSocialState: (state) => {
+      state.activeDialogue = void 0;
+      state.activeTrade = void 0;
+    }
+  }
+});
+var socialReducer = socialSlice.reducer;
+var socialActions = socialSlice.actions;
+
+// src/features/mechanics/slices/stealthSlice.ts
+import { createSlice as createSlice4 } from "@reduxjs/toolkit";
+var initialState4 = {
+  doorOpen: false,
+  alertLevel: 0
+};
+var stealthSlice = createSlice4({
+  name: "stealth",
+  initialState: initialState4,
+  reducers: {
+    setDoorOpen: (state, action) => {
+      state.doorOpen = action.payload;
+    },
+    bumpAlert: (state, action) => {
+      state.alertLevel = Math.max(0, Math.min(100, state.alertLevel + action.payload));
+    }
+  }
+});
+var stealthReducer = stealthSlice.reducer;
+var stealthActions = stealthSlice.actions;
+
+// src/features/entities/slices/npcsSlice.ts
+import { createEntityAdapter, createSlice as createSlice5 } from "@reduxjs/toolkit";
+var npcsAdapter = createEntityAdapter();
+var npcsSlice = createSlice5({
+  name: "npcs",
+  initialState: npcsAdapter.getInitialState(),
+  reducers: {
+    upsertNPC: npcsAdapter.upsertOne,
+    moveNPC: (state, action) => {
+      const target = state.entities[action.payload.id];
+      if (!target) return;
+      target.position = action.payload.position;
+    },
+    patchNPC: (state, action) => {
+      const target = state.entities[action.payload.id];
+      if (!target) return;
+      Object.assign(target, action.payload.patch);
+    }
+  }
+});
+var npcsReducer = npcsSlice.reducer;
+var npcsActions = npcsSlice.actions;
+var npcsSelectors = npcsAdapter.getSelectors(
+  (root) => root.npcs
+);
+
+// src/features/entities/slices/playerSlice.ts
+import { createSlice as createSlice6 } from "@reduxjs/toolkit";
+var initialState5 = {
+  name: "Scout",
+  hp: 100,
+  hidden: true,
+  position: { x: 1, y: 1 },
+  inventory: ["coin-pouch"]
+};
+var playerSlice = createSlice6({
+  name: "player",
+  initialState: initialState5,
+  reducers: {
+    setPosition: (state, action) => {
+      state.position = action.payload;
+    },
+    setHidden: (state, action) => {
+      state.hidden = action.payload;
+    },
+    patchPlayer: (state, action) => {
+      Object.assign(state, action.payload);
+    }
+  }
+});
+var playerReducer = playerSlice.reducer;
+var playerActions = playerSlice.actions;
+
+// src/features/store/slices/memorySlice.ts
+import { createSlice as createSlice7 } from "@reduxjs/toolkit";
+var initialState6 = {
+  records: []
+};
+var memorySlice = createSlice7({
+  name: "memory",
+  initialState: initialState6,
+  reducers: {
+    storeMemory: (state, action) => {
+      state.records.push(action.payload);
+    },
+    clearMemoryForNpc: (state, action) => {
+      state.records = state.records.filter((r) => r.npcId !== action.payload);
+    }
+  }
+});
+var memoryReducer = memorySlice.reducer;
+var memoryActions = memorySlice.actions;
+
+// src/features/store/slices/soulSlice.ts
+import { createSlice as createSlice8 } from "@reduxjs/toolkit";
+var initialState7 = {
+  exportsByNpc: {},
+  importedSoulTxIds: []
+};
+var soulSlice = createSlice8({
+  name: "soul",
+  initialState: initialState7,
+  reducers: {
+    markSoulExported: (state, action) => {
+      state.exportsByNpc[action.payload.npcId] = action.payload.txId;
+    },
+    markSoulImported: (state, action) => {
+      state.importedSoulTxIds.push(action.payload);
+    }
+  }
+});
+var soulReducer = soulSlice.reducer;
+var soulActions = soulSlice.actions;
+
+// src/features/terminal/slices/transcriptSlice.ts
+import { createSlice as createSlice9 } from "@reduxjs/toolkit";
+var initialState8 = {
+  entries: []
+};
+var transcriptSlice = createSlice9({
+  name: "transcript",
+  initialState: initialState8,
+  reducers: {
+    recordTranscript: (state, action) => {
+      state.entries.push(action.payload);
+    },
+    resetTranscript: (state) => {
+      state.entries = [];
+    }
+  }
+});
+var transcriptReducer = transcriptSlice.reducer;
+var transcriptActions = transcriptSlice.actions;
+
+// src/features/terminal/slices/uiSlice.ts
+import { createSlice as createSlice10 } from "@reduxjs/toolkit";
+var initialState9 = {
+  mode: "autoplay",
+  messages: []
+};
+var uiSlice = createSlice10({
+  name: "ui",
+  initialState: initialState9,
+  reducers: {
+    setMode: (state, action) => {
+      state.mode = action.payload;
+    },
+    addMessage: (state, action) => {
+      state.messages.push(action.payload);
+    }
+  }
+});
+var uiReducer = uiSlice.reducer;
+var uiActions = uiSlice.actions;
+
+// src/lib/commandRunner.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var runCommand = async (command, mode) => {
+  if (mode === "simulate") {
+    return { status: "simulated", output: "Simulated command execution." };
+  }
+  try {
+    const { stdout, stderr } = await execAsync(command.command, { timeout: 1e4 });
+    const output2 = [stdout, stderr].filter(Boolean).join("\n").trim();
+    return { status: "ok", output: output2 || "Command completed." };
+  } catch (error) {
+    const output2 = [error?.stdout, error?.stderr, error?.message].filter(Boolean).join("\n").trim();
+    return { status: "error", output: output2 || "Command failed." };
+  }
+};
+
+// src/lib/render.ts
+var cellAt = (pos, state) => {
+  const isBlocked = state.grid.blocked.some((b) => b.x === pos.x && b.y === pos.y);
+  if (isBlocked) return "#";
+  if (state.player.position.x === pos.x && state.player.position.y === pos.y) {
+    return "P";
+  }
+  for (const npc of Object.values(state.npcs.entities)) {
+    if (!npc) continue;
+    if (npc.position.x === pos.x && npc.position.y === pos.y) return npc.id === "miller" ? "M" : "D";
+  }
+  return ".";
+};
+var renderGrid = (state) => {
+  const rows = [];
+  for (let y = 0; y < state.grid.height; y += 1) {
+    const cells = [];
+    for (let x = 0; x < state.grid.width; x += 1) {
+      cells.push(cellAt({ x, y }, state));
+    }
+    rows.push(cells.join(" "));
+  }
+  return rows.join("\n");
+};
+
+// src/store.ts
+import { configureStore } from "@reduxjs/toolkit";
+
+// src/features/mechanics/slices/gridSlice.ts
+import { createSlice as createSlice11 } from "@reduxjs/toolkit";
+var initialState10 = {
+  width: 8,
+  height: 8,
+  blocked: [{ x: 4, y: 4 }, { x: 4, y: 5 }, { x: 6, y: 2 }]
+};
+var gridSlice = createSlice11({
+  name: "grid",
+  initialState: initialState10,
+  reducers: {
+    setGridSize: (state, action) => {
+      state.width = action.payload.width;
+      state.height = action.payload.height;
+    },
+    setBlocked: (state, action) => {
+      state.blocked = action.payload;
+    }
+  }
+});
+var gridReducer = gridSlice.reducer;
+var gridActions = gridSlice.actions;
+
+// src/features/store/slices/inventorySlice.ts
+import { createSlice as createSlice12 } from "@reduxjs/toolkit";
+var initialState11 = {
+  byOwner: {
+    player: ["coin-pouch"],
+    miller: ["medkit"]
+  }
+};
+var inventorySlice = createSlice12({
+  name: "inventory",
+  initialState: initialState11,
+  reducers: {
+    setOwnerInventory: (state, action) => {
+      state.byOwner[action.payload.ownerId] = action.payload.items;
+    }
+  }
+});
+var inventoryReducer = inventorySlice.reducer;
+var inventoryActions = inventorySlice.actions;
+
+// src/features/autoplay/slices/scenarioSlice.ts
+import { createSlice as createSlice13 } from "@reduxjs/toolkit";
+var steps = [
+  {
+    id: "stealth-door-open",
+    title: "Spatial Strategy & Stealth",
+    description: "Armory door is left open. Doomguard patrol processes observation and stores memory.",
+    eventType: "stealth",
+    commands: [
+      { group: "status", command: "forbocai status", expectedRoutes: ["GET /status"] },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc state doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc update doomguard faction Doomguards",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "The armory door is open"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_store",
+        command: 'forbocai memory store doomguard "Armory door found open at x:5, y:12"',
+        expectedRoutes: ["POST /npcs/{id}/memory"]
+      },
+      {
+        group: "memory_list",
+        command: "forbocai memory list doomguard",
+        expectedRoutes: ["GET /npcs/{id}/memory"]
+      },
+      {
+        group: "bridge_rules",
+        command: "forbocai bridge rules",
+        expectedRoutes: ["GET /bridge/rules"]
+      }
+    ]
+  },
+  {
+    id: "social-miller-encounter",
+    title: "Social Simulation",
+    description: "Miller encounter triggers recall, dialogue, and trade offer.",
+    eventType: "social",
+    commands: [
+      {
+        group: "npc_lifecycle",
+        command: "forbocai npc create miller",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc chat miller --text "I come in peace"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "memory_recall",
+        command: 'forbocai memory recall miller "player interaction"',
+        expectedRoutes: ["POST /npcs/{id}/memory/recall"]
+      },
+      {
+        group: "bridge_preset",
+        command: "forbocai bridge preset social",
+        expectedRoutes: ["POST /rules/presets/{id}"]
+      },
+      {
+        group: "soul_export",
+        command: "forbocai soul export miller",
+        expectedRoutes: ["POST /npcs/{id}/soul/export"]
+      },
+      {
+        group: "soul_list",
+        command: "forbocai soul list",
+        expectedRoutes: ["GET /souls"]
+      }
+    ]
+  },
+  {
+    id: "escape-realtime-pursuit",
+    title: "Real-Time Escape",
+    description: "Harness loop fires process commands and validates jump force via bridge rules.",
+    eventType: "escape",
+    commands: [
+      {
+        group: "bridge_validate",
+        command: "forbocai bridge validate doomguard-jump",
+        expectedRoutes: ["POST /bridge/validate", "POST /bridge/validate/{id}"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player is escaping"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player jumped the gap"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "npc_process_chat",
+        command: 'forbocai npc process doomguard "Player reached the gate"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost run smoke",
+        expectedRoutes: ["POST /ghost/run"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost status ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/status"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost results ghost-001",
+        expectedRoutes: ["GET /ghost/{id}/results"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost stop ghost-001",
+        expectedRoutes: ["POST /ghost/{id}/stop"]
+      },
+      {
+        group: "ghost_lifecycle",
+        command: "forbocai ghost history",
+        expectedRoutes: ["GET /ghost/history"]
+      }
+    ]
+  },
+  {
+    id: "persistence-recovery",
+    title: "Persistence & Recovery",
+    description: "Exercises memory export/clear and soul import/chat continuity.",
+    eventType: "persistence",
+    commands: [
+      {
+        group: "memory_export",
+        command: "forbocai memory export doomguard",
+        expectedRoutes: ["local only"]
+      },
+      {
+        group: "memory_clear",
+        command: "forbocai memory clear doomguard",
+        expectedRoutes: ["DELETE /npcs/{id}/memory/clear"]
+      },
+      {
+        group: "soul_import",
+        command: "forbocai soul import tx-demo-001",
+        expectedRoutes: ["GET /souls/{txId}", "POST /npcs/import"]
+      },
+      {
+        group: "soul_chat",
+        command: 'forbocai soul chat doomguard --text "What do you remember?"',
+        expectedRoutes: ["POST /npcs/{id}/directive", "POST /npcs/{id}/context", "POST /npcs/{id}/verdict"]
+      },
+      {
+        group: "cortex_init",
+        command: "forbocai cortex init --remote",
+        expectedRoutes: ["POST /cortex/init"]
+      }
+    ]
+  }
+];
+var scenarioSlice = createSlice13({
+  name: "scenario",
+  initialState: {
+    steps
+  },
+  reducers: {}
+});
+var scenarioReducer = scenarioSlice.reducer;
+
+// src/store.ts
+var createTestGameStore = () => configureStore({
+  reducer: {
+    npcs: npcsReducer,
+    player: playerReducer,
+    grid: gridReducer,
+    stealth: stealthReducer,
+    social: socialReducer,
+    bridge: bridgeReducer,
+    memory: memoryReducer,
+    inventory: inventoryReducer,
+    soul: soulReducer,
+    ui: uiReducer,
+    transcript: transcriptReducer,
+    scenario: scenarioReducer,
+    harness: harnessReducer
+  }
+});
+
+// src/game.ts
+var nowId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var applyScenarioEvent = async (step, store) => {
+  if (step.eventType === "stealth") {
+    store.dispatch(stealthActions.setDoorOpen(true));
+    store.dispatch(stealthActions.bumpAlert(25));
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "doomguard",
+        name: "Doomguard Patrol",
+        faction: "Doomguards",
+        hp: 100,
+        suspicion: 40,
+        inventory: [],
+        knownSecrets: [],
+        position: { x: 5, y: 10 }
+      })
+    );
+    const movement = capMoveDistance(store.getState().bridge, 6);
+    store.dispatch(npcsActions.moveNPC({ id: "doomguard", position: { x: 5, y: 10 + movement.allowedDistance } }));
+    store.dispatch(
+      memoryActions.storeMemory({
+        npcId: "doomguard",
+        text: "Armory door found open at x:5, y:12",
+        importance: 0.9
+      })
+    );
+  }
+  if (step.eventType === "social") {
+    store.dispatch(
+      npcsActions.upsertNPC({
+        id: "miller",
+        name: "Miller",
+        faction: "Neutral",
+        hp: 100,
+        suspicion: 50,
+        inventory: ["medkit"],
+        knownSecrets: ["player_stole_rations"],
+        position: { x: 5, y: 12 }
+      })
+    );
+    store.dispatch(
+      socialActions.setDialogue("I know you took those rations. I'm not giving you this medkit unless you pay double.")
+    );
+    store.dispatch(socialActions.setTradeOffer({ npcId: "miller", item: "medkit", price: 100 }));
+    store.dispatch(npcsActions.patchNPC({ id: "miller", patch: { suspicion: 75 } }));
+    store.dispatch(bridgeActions.loadBridgePreset("social"));
+  }
+  if (step.eventType === "escape") {
+    store.dispatch(playerActions.setHidden(false));
+    const jump = validateJump(store.getState().bridge, 800);
+    if (!jump.valid) {
+      store.dispatch(uiActions.addMessage(`Bridge blocked jump: ${jump.reason}`));
+      store.dispatch(npcsActions.patchNPC({ id: "doomguard", patch: { hp: 90 } }));
+    }
+    for (let i = 0; i < 3; i += 1) {
+      store.dispatch(stealthActions.bumpAlert(10));
+      await delay(300);
+    }
+  }
+  if (step.eventType === "persistence") {
+    store.dispatch(soulActions.markSoulExported({ npcId: "doomguard", txId: "tx-demo-001" }));
+    store.dispatch(memoryActions.clearMemoryForNpc("doomguard"));
+    store.dispatch(soulActions.markSoulImported("tx-demo-001"));
+  }
+};
+var runGame = async ({
+  mode,
+  execute
+}) => {
+  const store = createTestGameStore();
+  store.dispatch(uiActions.setMode(mode));
+  store.dispatch(
+    npcsActions.upsertNPC({
+      id: "scout",
+      name: "Scout",
+      faction: "Player",
+      hp: 100,
+      suspicion: 0,
+      inventory: ["coin-pouch"],
+      knownSecrets: [],
+      position: { x: 1, y: 1 }
+    })
+  );
+  const rl = mode === "manual" ? createInterface({ input, output }) : null;
+  for (const step of store.getState().scenario.steps) {
+    if (mode === "manual") {
+      console.log(`
+== ${step.title} ==
+${step.description}
+`);
+      console.log(renderGrid(store.getState()));
+      await rl?.question("Press Enter to run this scenario step...");
+    } else {
+      console.log(`
+== ${step.title} ==`);
+      console.log(step.description);
+    }
+    await applyScenarioEvent(step, store);
+    for (const command of step.commands) {
+      const result = await runCommand(command, execute);
+      store.dispatch(harnessActions.markCovered(command.group));
+      store.dispatch(
+        transcriptActions.recordTranscript({
+          id: nowId(),
+          scenarioId: step.id,
+          commandGroup: command.group,
+          command: command.command,
+          expectedRoutes: command.expectedRoutes,
+          status: result.status,
+          output: result.output,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      console.log(`[${result.status}] ${command.command}`);
+    }
+  }
+  rl?.close();
+  const state = store.getState();
+  const missingGroups = selectMissingGroups(state.harness.covered);
+  const complete = missingGroups.length === 0;
+  const summary = complete ? `Run complete: all ${Object.keys(state.harness.covered).length} command groups were exercised.` : `Run incomplete: missing command groups -> ${missingGroups.join(", ")}`;
+  console.log("\n=== Transcript Summary ===");
+  for (const entry of state.transcript.entries) {
+    console.log(
+      `${entry.at} | ${entry.commandGroup} | ${entry.status} | ${entry.command} | routes: ${entry.expectedRoutes.join(", ")}`
+    );
+  }
+  console.log(`
+${summary}`);
+  return {
+    complete,
+    missingGroups,
+    transcript: state.transcript.entries,
+    summary
+  };
+};
+
+export {
+  REQUIRED_GROUPS,
+  runGame
+};

package/dist/cli.d.mts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Runs the CLI entry flow and exits with status code:
+ * - `0` when coverage is complete
+ * - `2` when required command groups are missing
+ * User Story: As a CI user, I want exit codes to reflect coverage completeness so failures are actionable.
+ */
+declare const runCli: () => Promise<void>;
+/**
+ * Test-only exports for direct unit coverage of internal CLI helpers.
+ */
+declare const __test: {
+    usage: () => void;
+    getArgValue: (name: string) => string | undefined;
+};
+
+export { __test, runCli };