@myclaw163/clawclaw-cli 0.6.54

package/src/commands/do.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeDoOptions, parseIntents } from './do.js';
+
+describe('normalizeDoOptions', () => {
+  it('joins unquoted speech words passed as extra arguments', () => {
+    expect(normalizeDoOptions({ speech: 'I' }, ['saw', 'player3']).speech).toBe('I saw player3');
+  });
+
+  it('leaves extra args alone when there is no speech option', () => {
+    expect(normalizeDoOptions({}, ['unused'])).toEqual({});
+  });
+});
+
+describe('parseIntents', () => {
+  it('builds speech intents', () => {
+    const action = parseIntents({ speech: 'hi' })[0].build().toJSON();
+    expect(action).toMatchObject({ action: 'speech', text: 'hi' });
+  });
+
+  it('includes audio_url when url is provided', () => {
+    const action = parseIntents({ speech: 'hi', url: 'https://cdn.example.com/a.mp3' })[0].build().toJSON();
+    expect(action).toMatchObject({
+      action: 'speech',
+      text: 'hi',
+      audio_url: 'https://cdn.example.com/a.mp3',
+    });
+  });
+
+  it('builds vote intents', () => {
+    const action = parseIntents({ vote: 'player1' })[0].build().toJSON();
+    expect(action).toMatchObject({ action: 'vote', target: 'player1' });
+  });
+
+  it('ignores removed direct-control options', () => {
+    expect(parseIntents({ move: '2424,237', task: true, kill: 'p1', report: true, alarm: true })).toEqual([]);
+  });
+});

package/src/commands/do.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import { GameClient } from '../lib/game-client.js';
+import { maybeSynthesizeSpeechAudioUrl } from '../lib/tts-speech.js';
+import { Action } from '../sdk/action.js';
+import { EventStore } from '../pipeline/event-store.js';
+
+interface ActionIntent {
+  build(): Action;
+}
+
+export function normalizeDoOptions(opts: Record<string, any>, extraArgs: string[] = []): Record<string, any> {
+  const normalized = { ...opts };
+  if (normalized.speech && extraArgs.length > 0) {
+    normalized.speech = [normalized.speech, ...extraArgs].join(' ');
+  }
+
+  return normalized;
+}
+
+export function parseIntents(opts: Record<string, any>): ActionIntent[] {
+  const intents: ActionIntent[] = [];
+  if (opts.speech) intents.push({ build: () => Action.speech(opts.speech, undefined, opts.url) });
+  if (opts.vote)   intents.push({ build: () => Action.vote(opts.vote) });
+  return intents;
+}
+
+export function createDoCommand(): Command {
+  return new Command('do')
+    .alias('d')
+    .description('Execute player communication actions (speech/vote/think)')
+    .option('-s, --speech <text>', 'Say something')
+    .option('--url <url>', 'Optional audio URL for speech')
+    .option('-v, --vote <target>', 'Vote for player')
+    .option('--think <text>', 'Send thinking content visible only to spectators. Standalone (e.g. `do --think "..."`) submits a no-op think action; combined with another action, attaches as that action\'s thinking_content.')
+    .argument('[extra...]', 'Additional unquoted speech words')
+    .action(async (extraArgs: string[], opts) => {
+      opts = normalizeDoOptions(opts, extraArgs);
+
+      if (!opts.speech && !opts.vote && !opts.think) {
+        console.error('No action specified. Use -s, -v, or --think.');
+        process.exit(1);
+      }
+
+      const { isStrategyRunning } = await import('../strategies/strategy-loop.js');
+      const strategyActive = isStrategyRunning();
+
+      if (strategyActive && !opts.speech && !opts.vote && !opts.think) {
+        console.log(JSON.stringify({
+          error: 'strategy_running',
+          message: 'Strategy is controlling the character. Speech (-s), vote (-v), and --think remain available.',
+        }, null, 2));
+        process.exit(1);
+      }
+
+      const client = GameClient.fromAuth();
+      await client.discoverGameServer();
+
+      if (opts.speech && !opts.url) {
+        opts.url = await maybeSynthesizeSpeechAudioUrl(opts.speech, opts.url, client);
+      }
+
+      const intents = parseIntents(opts);
+      if (intents.length === 0 && opts.think) {
+        intents.push({ build: () => Action.think() });
+      }
+
+      const first = intents[0];
+      let action = first.build();
+      if (opts.think) action = action.withThinking(opts.think);
+      const result = await client.submitAction(action.toJSON() as any);
+
+      try {
+        const store = EventStore.forActiveAccount();
+        store.appendNewEvents(result);
+      } catch {}
+
+      if (intents.length === 1) {
+        console.log(JSON.stringify({ action: action.toJSON(), result: result ?? 'ok' }, null, 2));
+        return;
+      }
+
+      const submitted = [{ action: action.toJSON(), result: result ?? 'ok' }];
+      for (const intent of intents.slice(1)) {
+        const nextAction = intent.build();
+        const nextResult = await client.submitAction(nextAction.toJSON() as any);
+        try {
+          const store = EventStore.forActiveAccount();
+          store.appendNewEvents(nextResult);
+        } catch {}
+        submitted.push({ action: nextAction.toJSON(), result: nextResult ?? 'ok' });
+      }
+
+      console.log(JSON.stringify({ actions: submitted }, null, 2));
+    });
+}

package/src/commands/events.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { EventStore } from '../pipeline/event-store.js';
+
+export function createEventsCommand(): Command {
+  return new Command('events')
+    .alias('e')
+    .description('Query game events')
+    .option('-n, --last <count>', 'Show last N events', '10')
+    .option('--clear', 'Clear event history')
+    .option('--type <type>', 'Filter by event type')
+    .action(async (opts) => {
+      const store = EventStore.forLatestGame();
+      if (opts.clear) {
+        store.clear();
+        console.log(JSON.stringify({ message: 'Events cleared.' }));
+        return;
+      }
+      let events = store.tail(parseInt(opts.last));
+      if (opts.type) events = events.filter(e => e.type === opts.type);
+      console.log(JSON.stringify(events, null, 2));
+    });
+}

package/src/commands/game-map.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { summarizeGameMap } from './game.js';
+
+const mapData = {
+  rooms: [{ name: '酒吧', polygon: [[1, 2]] }],
+  all_task_locations: [
+    { name: '修线', room: '酒吧', x: 1, y: 2, faction: 'lobster' },
+    { name: '破坏', room: '控制室', x: 3, y: 4, faction: 'crab' },
+  ],
+};
+
+describe('summarizeGameMap', () => {
+  it('does not include ASCII by default', () => {
+    const summary = summarizeGameMap(mapData);
+    expect(summary.rooms).toEqual([{ name: '酒吧', polygon: [[1, 2]] }]);
+    expect(summary.task_locations.lobster).toEqual([{ name: '修线', room: '酒吧', x: 1, y: 2 }]);
+    expect(summary.task_locations.crab).toEqual([{ name: '破坏', room: '控制室', x: 3, y: 4 }]);
+    expect(summary).not.toHaveProperty('ascii_map');
+  });
+
+  it('includes packaged ASCII map only with --ascii', () => {
+    const summary = summarizeGameMap(mapData, { ascii: true });
+    expect(typeof summary.ascii_map).toBe('string');
+    expect(summary.ascii_map).toContain('酒吧');
+    expect(summary.ascii_map).toContain('5号走廊');
+    expect(summary).not.toHaveProperty('corridors');
+  });
+});

package/src/commands/game-start-plan.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import {
+  gameStrategyIdentity,
+  planGameStartAction,
+  strategyRuntimeMatchesIdentity,
+} from './game.js';
+
+describe('planGameStartAction', () => {
+  it('returns the running game start pid when a stream is already alive', () => {
+    expect(planGameStartAction({
+      gameStartPid: 1234,
+      daemonPid: 4321,
+      hasMatchState: true,
+      queueStatus: 'allocated',
+      feedPhase: 'wandering',
+    })).toEqual({ kind: 'already_running', pid: 1234 });
+  });
+
+  it('resumes queue polling when a daemon is alive with match-state', () => {
+    expect(planGameStartAction({
+      daemonPid: 4321,
+      hasMatchState: true,
+      queueStatus: 'queued',
+      feedPhase: null,
+    })).toEqual({ kind: 'resume_queue' });
+  });
+
+  it('resumes queue polling when a daemon reports matching', () => {
+    expect(planGameStartAction({
+      daemonPid: 4321,
+      hasMatchState: false,
+      queueStatus: 'not_in_queue',
+      feedPhase: 'matching',
+    })).toEqual({ kind: 'resume_queue' });
+  });
+
+  it('starts fresh when the only live daemon is idle in the lobby', () => {
+    expect(planGameStartAction({
+      daemonPid: 4321,
+      hasMatchState: false,
+      queueStatus: 'not_in_queue',
+      feedPhase: 'lobby',
+    })).toEqual({ kind: 'fresh_start' });
+  });
+
+  it('attaches to a live non-lobby daemon without queue state', () => {
+    expect(planGameStartAction({
+      daemonPid: 4321,
+      hasMatchState: false,
+      queueStatus: 'not_in_queue',
+      feedPhase: 'wandering',
+    })).toEqual({ kind: 'attach_daemon' });
+  });
+
+  it('resumes an allocated match when no daemon is alive', () => {
+    expect(planGameStartAction({
+      daemonPid: null,
+      hasMatchState: false,
+      queueStatus: 'allocated',
+      feedPhase: null,
+    })).toEqual({ kind: 'resume_allocated' });
+  });
+
+  it('resumes queue polling for queued and already_in_queue states without a daemon', () => {
+    for (const queueStatus of ['queued', 'already_in_queue']) {
+      expect(planGameStartAction({
+        daemonPid: null,
+        hasMatchState: false,
+        queueStatus,
+        feedPhase: null,
+      })).toEqual({ kind: 'resume_queue' });
+    }
+  });
+
+  it('starts fresh when no stream, daemon, or queue state can be recovered', () => {
+    expect(planGameStartAction({
+      daemonPid: null,
+      hasMatchState: false,
+      queueStatus: 'not_in_queue',
+      feedPhase: null,
+    })).toEqual({ kind: 'fresh_start' });
+  });
+});
+
+describe('game strategy identity', () => {
+  it('derives game id, role, and alive status from current server context', () => {
+    expect(gameStrategyIdentity(
+      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: false } },
+      null,
+    )).toEqual({
+      gameId: 'game-1',
+      role: 'shrimp_generic',
+      alive: false,
+    });
+  });
+
+  it('prefers role_info role over state role', () => {
+    expect(gameStrategyIdentity(
+      { game_id: 'game-1', you: { role: 'shrimp_generic', is_alive: true } },
+      { data: { role: 'crab_generic' } },
+    )).toEqual({
+      gameId: 'game-1',
+      role: 'crab_generic',
+      alive: true,
+    });
+  });
+
+  it('preserves only a running strategy from the same current game', () => {
+    const identity = { gameId: 'game-1', role: 'shrimp_generic', alive: true };
+    expect(strategyRuntimeMatchesIdentity({
+      strategy: 'task-report',
+      pid: 123,
+      gameId: 'game-1',
+      role: 'shrimp_generic',
+      running: true,
+    }, identity)).toBe(true);
+
+    expect(strategyRuntimeMatchesIdentity({
+      strategy: 'task-report',
+      pid: 123,
+      gameId: 'old-game',
+      role: 'shrimp_generic',
+      running: true,
+    }, identity)).toBe(false);
+
+    expect(strategyRuntimeMatchesIdentity({
+      strategy: 'task-report',
+      pid: 123,
+      gameId: 'game-1',
+      role: 'crab_generic',
+      running: true,
+    }, identity)).toBe(false);
+
+    expect(strategyRuntimeMatchesIdentity({
+      strategy: 'task-report',
+      pid: 123,
+      gameId: 'game-1',
+      role: 'shrimp_generic',
+      running: false,
+    }, identity)).toBe(false);
+  });
+});