@couch-kit/cli 0.2.6 → 0.3.1

package/dist/index.js

@@ -1928,12 +1928,35 @@ function toErrorMessage(error) {
     return error.message;
   return String(error);
 }
-var MAX_FRAME_SIZE, DEFAULT_DISCONNECT_TIMEOUT;
+var DEFAULT_HTTP_PORT = 8080, DEFAULT_WS_PORT_OFFSET = 2, DEFAULT_WS_PATH = "/ws", MAX_FRAME_SIZE, DEFAULT_DISCONNECT_TIMEOUT;
 var init_constants = __esm(() => {
   MAX_FRAME_SIZE = 1024 * 1024;
   DEFAULT_DISCONNECT_TIMEOUT = 5 * 60 * 1000;
 });
 
+// ../core/src/replay.ts
+function replayActions(recording, reducer) {
+  const snapshots = [];
+  let currentState = recording.initialState;
+  for (let i = 0;i < recording.actions.length; i++) {
+    const { action, timestamp } = recording.actions[i];
+    currentState = reducer(currentState, action);
+    snapshots.push({
+      state: currentState,
+      action,
+      timestamp,
+      index: i
+    });
+  }
+  const endTimestamp = recording.endTimestamp ?? (recording.actions.length > 0 ? recording.actions[recording.actions.length - 1].timestamp : recording.startTimestamp);
+  return {
+    finalState: currentState,
+    snapshots,
+    duration: endTimestamp - recording.startTimestamp,
+    actionCount: recording.actions.length
+  };
+}
+
 // ../core/src/index.ts
 var init_src = __esm(() => {
   init_types();
@@ -2035,7 +2058,7 @@ var simulateCommand;
 var init_simulate = __esm(() => {
   init_esm();
   init_src();
-  simulateCommand = new Command("simulate").description("Spawns headless bots to simulate players").option("-n, --count <number>", "Number of bots", "4").option("-u, --url <url>", "WebSocket URL of host", "ws://localhost:8082").option("-i, --interval <ms>", "Action interval in ms", "1000").action(async (options) => {
+  simulateCommand = new Command("simulate").description("Spawns headless bots to simulate players").option("-n, --count <number>", "Number of bots", "4").option("-u, --url <url>", "WebSocket URL of host", `ws://localhost:${DEFAULT_HTTP_PORT + DEFAULT_WS_PORT_OFFSET}${DEFAULT_WS_PATH}`).option("-i, --interval <ms>", "Action interval in ms", "1000").action(async (options) => {
     const count = parseInt(options.count);
     const url = options.url;
     const interval = parseInt(options.interval);
@@ -2098,6 +2121,18 @@ __export(exports_init, {
 });
 import fs2 from "node:fs";
 import path2 from "node:path";
+function detectPackageManager2() {
+  if (typeof Bun !== "undefined")
+    return "bun";
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.includes("yarn"))
+    return "yarn";
+  if (userAgent.includes("pnpm"))
+    return "pnpm";
+  if (userAgent.includes("bun"))
+    return "bun";
+  return "npm";
+}
 var initCommand;
 var init_init = __esm(() => {
   init_esm();
@@ -2149,6 +2184,8 @@ var init_init = __esm(() => {
           noEmit: true,
           jsx: "react-jsx",
           strict: true,
+          noUncheckedIndexedAccess: true,
+          exactOptionalPropertyTypes: true,
           noUnusedLocals: true,
           noUnusedParameters: true,
           noFallthroughCasesInSwitch: true
@@ -2232,12 +2269,53 @@ export default App
       fs2.writeFileSync(path2.join(targetDir, "src/index.css"), `
 body { margin: 0; background: #111; color: #fff; }
 `);
+      const reducerContent = `import type { IAction, IGameState, GameReducer } from "@couch-kit/core";
+
+export interface GameState extends IGameState {
+  score: number;
+  round: number;
+}
+
+export interface GameAction extends IAction {
+  type: "SCORE" | "NEXT_ROUND" | "RESET";
+  payload?: { points?: number };
+}
+
+export const gameReducer: GameReducer<GameState, GameAction> = (state, action) => {
+  switch (action.type) {
+    case "SCORE":
+      return { ...state, score: state.score + (action.payload?.points ?? 1) };
+    case "NEXT_ROUND":
+      return { ...state, round: state.round + 1 };
+    case "RESET":
+      return { ...state, score: 0, round: 1 };
+    default:
+      return state;
+  }
+};
+
+export const initialState: GameState = {
+  status: "lobby",
+  players: {},
+  score: 0,
+  round: 1,
+};
+`;
+      fs2.writeFileSync(path2.join(targetDir, "src/reducer.ts"), reducerContent);
+      const gitignoreContent = `node_modules/
+dist/
+lib/
+.DS_Store
+*.local
+`;
+      fs2.writeFileSync(path2.join(targetDir, ".gitignore"), gitignoreContent);
+      const pm = detectPackageManager2();
       console.log(`Done! Created new project in ${name}`);
       console.log(`
 Next steps:
   cd ${name}
-  bun install
-  bun run dev
+  ${pm} install
+  ${pm} run dev
 `);
     } catch (e) {
       console.error(`Init failed: ${toErrorMessage(e)}`);
@@ -2246,6 +2324,133 @@ Next steps:
   });
 });
 
+// src/commands/replay.ts
+var exports_replay = {};
+__export(exports_replay, {
+  replay: () => replay2
+});
+import { resolve } from "node:path";
+var replay2;
+var init_replay = __esm(() => {
+  init_esm();
+  init_src();
+  replay2 = new Command("replay").description("Replay a recorded game session against a reducer").argument("<recording>", "Path to recording JSON file").argument("<reducer>", "Path to reducer module (must export default or named 'reducer')").option("--snapshots", "Output intermediate state snapshots", false).option("--json", "Output as formatted JSON", false).action(async (recordingPath, reducerPath, options) => {
+    try {
+      const resolvedRecordingPath = resolve(recordingPath);
+      const recordingFile = Bun.file(resolvedRecordingPath);
+      const exists = await recordingFile.exists();
+      if (!exists) {
+        console.error(`Error: Recording file not found: ${recordingPath}`);
+        process.exit(1);
+      }
+      const recording = await recordingFile.json();
+      if (!recording.initialState || !Array.isArray(recording.actions)) {
+        console.error("Error: Invalid recording format. Expected { initialState, actions[] }");
+        process.exit(1);
+      }
+      const resolvedReducerPath = resolve(reducerPath);
+      const reducerModule = await import(resolvedReducerPath);
+      const reducer = reducerModule.default ?? reducerModule.reducer;
+      if (typeof reducer !== "function") {
+        console.error("Error: Reducer module must export a default function or named 'reducer' export");
+        process.exit(1);
+      }
+      const result = replayActions(recording, reducer);
+      if (options.json) {
+        const output = options.snapshots ? result : {
+          finalState: result.finalState,
+          duration: result.duration,
+          actionCount: result.actionCount
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        console.log(`Replayed ${result.actionCount} actions in ${result.duration}ms`);
+        console.log(`
+Final state:`);
+        console.log(JSON.stringify(result.finalState, null, 2));
+        if (options.snapshots) {
+          console.log(`
+Snapshots (${result.snapshots.length}):`);
+          for (const snapshot of result.snapshots) {
+            console.log(`
+  [${snapshot.index}] ${JSON.stringify(snapshot.action)} @ ${snapshot.timestamp}`);
+            console.log(`  State: ${JSON.stringify(snapshot.state)}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Error: ${toErrorMessage(error)}`);
+      process.exit(1);
+    }
+  });
+});
+
+// src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  dev: () => dev
+});
+import { resolve as resolve2 } from "node:path";
+import { networkInterfaces } from "node:os";
+function getLanIp() {
+  const interfaces = networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    const nets = interfaces[name];
+    if (!nets)
+      continue;
+    for (const net of nets) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return null;
+}
+var dev;
+var init_dev = __esm(() => {
+  init_esm();
+  init_src();
+  dev = new Command("dev").description("Start development server with LAN access for mobile testing").option("-p, --port <port>", "Port number", "5173").option("--host", "Expose to LAN", true).option("--open", "Open browser automatically", false).action(async (options) => {
+    try {
+      const port = parseInt(options.port, 10);
+      const cwd = process.cwd();
+      let vite;
+      try {
+        const vitePkg = "vite";
+        vite = await import(vitePkg);
+      } catch {
+        console.error("Error: Vite is not installed. Run: bun add -d vite");
+        process.exit(1);
+      }
+      const lanIp = getLanIp();
+      console.log(`Starting Couch Kit dev server...
+`);
+      const server = await vite.createServer({
+        root: cwd,
+        server: {
+          port,
+          host: options.host ? "0.0.0.0" : "localhost",
+          open: options.open
+        },
+        configFile: resolve2(cwd, "vite.config.ts")
+      });
+      await server.listen();
+      console.log(`  Local:   http://localhost:${port}/`);
+      if (lanIp) {
+        console.log(`  LAN:     http://${lanIp}:${port}/`);
+        console.log(`
+  Scan QR or open LAN URL on your mobile device`);
+      }
+      console.log(`
+  Press Ctrl+C to stop
+`);
+    } catch (error) {
+      console.error(`Error: ${toErrorMessage(error)}`);
+      process.exit(1);
+    }
+  });
+});
+
 // src/index.ts
 init_esm();
 import { createRequire as createRequire2 } from "node:module";
@@ -2267,6 +2472,16 @@ program2.command("init").description("Scaffolds a new web controller project").a
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), exports_init));
   await initCommand2.parseAsync(["init", name], { from: "user" });
 });
+program2.command("replay").description("Replay a recorded game session against a reducer").argument("<recording>", "Path to recording JSON file").argument("<reducer>", "Path to reducer module").option("--snapshots", "Output intermediate state snapshots").option("--json", "Output as formatted JSON").action(async (recording, reducer, options) => {
+  const { replay: replay3 } = await Promise.resolve().then(() => (init_replay(), exports_replay));
+  await replay3.parseAsync(["replay", recording, reducer, ...reconstructArgs(options)], { from: "user" });
+});
+program2.command("dev").description("Start development server with LAN access").option("-p, --port <port>", "Port number", "5173").option("--host", "Expose to LAN").option("--open", "Open browser automatically").action(async (options) => {
+  const { dev: dev2 } = await Promise.resolve().then(() => (init_dev(), exports_dev));
+  await dev2.parseAsync(["dev", ...reconstructArgs(options)], {
+    from: "user"
+  });
+});
 function reconstructArgs(options) {
   const args = [];
   for (const [key, value] of Object.entries(options)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@couch-kit/cli",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -36,7 +36,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@couch-kit/core": "0.7.0",
+    "@couch-kit/core": "0.8.1",
     "commander": "^12.0.0"
   },
   "devDependencies": {