storymode-cli 1.1.2 → 1.2.1

package/src/player.mjs

@@ -1,3 +1,9 @@
+import { createServer } from 'node:net';
+import { unlinkSync, existsSync } from 'node:fs';
+import { mapEventToAnimation, pickSpeech, ONE_SHOT_ANIMS, IDLE_ANIM, SLEEP_ANIM, SLEEP_TIMEOUT_S, narrateEvent, SessionContext, StateEngine } from './reactive.mjs';
+import { createAgent } from './agent.mjs';
+import { getApiKey, hasSeenKeyPrompt, promptForApiKey } from './config.mjs';
+
 const { stdout, stdin } = process;
 
 export function playAnimation(framesData) {
@@ -201,6 +207,436 @@ export function playCompanion(framesData) {
   });
 }
 
+/**
+ * Reactive companion player — responds to Claude Code events via Unix socket.
+ *
+ * @param {Map<string, {fps: number, frames: string[][]}>} animMap - All animations keyed by name
+ * @param {object} [opts]
+ * @param {string} [opts.characterName] - Character name for status display
+ * @param {object} [opts.character] - Character data {name, backstory, ...} for LLM personality
+ * @param {object} [opts.personality] - Full personality.json data { character, disposition, animations, speech }
+ * @param {boolean} [opts.fullscreen] - Use alt screen (full-screen mode)
+ * @param {boolean} [opts.noAi] - Disable LLM personality layer
+ * @param {string} [opts.model] - Anthropic model ID for personality layer
+ */
+export async function playReactiveCompanion(animMap, opts = {}) {
+  const characterName = opts.characterName || 'companion';
+  const personality = opts.personality || null;
+  let character = opts.noAi ? null : (personality || opts.character || null);
+  const fullscreen = !!opts.fullscreen;
+
+  // --- API key prompt (before terminal setup) ---
+  if (character && !opts.noAi && !getApiKey()) {
+    if (!hasSeenKeyPrompt()) {
+      // First time: full interactive prompt
+      await promptForApiKey('first-run');
+    } else {
+      // Subsequent launches: short reminder
+      process.stderr.write('  AI personality: OFF — press [a] to add your API key\n');
+    }
+  }
+
+  // Find idle animation (required)
+  const idleData = animMap.get(IDLE_ANIM);
+  if (!idleData || idleData.frames.length === 0) {
+    console.log('No idle animation found. Need "idle breathing" animation.');
+    return Promise.resolve();
+  }
+
+  // Calculate maxLines across ALL animations for stable layout
+  let maxLines = 0;
+  for (const [, data] of animMap) {
+    for (const frame of data.frames) {
+      if (frame.length > maxLines) maxLines = frame.length;
+    }
+  }
+
+  // Speech bubble: max 3 lines + border (top + bottom) + blank line = 6 extra lines
+  const SPEECH_CLEAR_MS = 6000;
+  const BUBBLE_MAX_LINES = 3;
+  const bubbleLines = BUBBLE_MAX_LINES + 3; // top border + text lines + bottom border
+
+  // Status line + quit hint + speech bubble area
+  const totalLines = maxLines + 1 + bubbleLines;
+
+  // Animation state
+  let currentAnimName = IDLE_ANIM;
+  let currentFrames = idleData.frames;
+  let currentFps = idleData.fps || 16;
+  let frameIdx = 0;
+  let loopCount = 0;
+  let oneShotLoopsRemaining = 0; // >0 means playing a one-shot
+  let quit = false;
+
+  // Sleep state
+  let lastEventTime = Date.now();
+  let sleeping = false;
+
+  // Speech bubble state
+  let speechText = null;
+  let speechSetAt = 0;
+  let lastSpeech = null;
+
+  // Recent animation tracking (avoid repeats)
+  const recentAnims = [];
+
+  // Session context
+  const sessionCtx = new SessionContext();
+
+  // State engine — tracks internal dimensions over time
+  // Extract state dimensions (skip 'drives' — it's for the LLM, not the engine)
+  const rawState = personality?.state;
+  const stateConfig = rawState ? Object.fromEntries(
+    Object.entries(rawState).filter(([k]) => k !== 'drives')
+  ) : null;
+  const stateEngine = new StateEngine(stateConfig);
+
+  // Personality layer (LLM agent) — requires character data + API key
+  const agentOpts = {
+    model: opts.model,
+    getState: () => stateEngine.active ? stateEngine.toJSON() : null,
+  };
+  function onAgentReaction(reaction) {
+    if (reaction.animation && animMap.has(reaction.animation)) {
+      switchAnimation(reaction.animation, ONE_SHOT_ANIMS.has(reaction.animation) ? 'one-shot' : 'loop');
+    }
+    if (reaction.speech) {
+      speechText = reaction.speech;
+      speechSetAt = Date.now();
+      lastSpeech = reaction.speech;
+    }
+  }
+  let agent = character
+    ? createAgent(character, [...animMap.keys()], onAgentReaction, agentOpts)
+    : null;
+
+  // Socket path
+  const sockPath = `/tmp/storymode-companion-${process.pid}.sock`;
+
+  // Clean up stale socket
+  if (existsSync(sockPath)) {
+    try { unlinkSync(sockPath); } catch { /* ignore */ }
+  }
+
+  // --- Terminal setup ---
+  if (fullscreen) {
+    // Alt screen, hide cursor, clear
+    stdout.write('\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H');
+  } else {
+    stdout.write('\x1b[?25l'); // hide cursor
+    // Reserve space
+    for (let i = 0; i < totalLines; i++) {
+      stdout.write('\n');
+    }
+    stdout.write(`\x1b[${totalLines}A`);
+    stdout.write('\x1b7'); // save cursor position
+  }
+
+  function switchAnimation(animName, type) {
+    if (!animMap.has(animName)) {
+      // Fallback to idle if animation not found
+      if (animName === IDLE_ANIM) return;
+      animName = IDLE_ANIM;
+      type = 'loop';
+    }
+
+    const data = animMap.get(animName);
+    currentAnimName = animName;
+    currentFrames = data.frames;
+    currentFps = data.fps || 16;
+    frameIdx = 0;
+    loopCount = 0;
+
+    if (type === 'one-shot' || ONE_SHOT_ANIMS.has(animName)) {
+      oneShotLoopsRemaining = 2; // play 2 loops for one-shot
+    } else {
+      oneShotLoopsRemaining = 0;
+    }
+
+    // Track recent
+    recentAnims.push(animName);
+    if (recentAnims.length > 3) recentAnims.shift();
+  }
+
+  /** Word-wrap text to fit inside a bubble of given inner width */
+  function wrapText(text, width) {
+    const words = text.split(' ');
+    const lines = [];
+    let line = '';
+    for (const word of words) {
+      if (line.length + word.length + (line ? 1 : 0) > width) {
+        if (line) lines.push(line);
+        line = word.slice(0, width); // truncate long words
+      } else {
+        line = line ? line + ' ' + word : word;
+      }
+    }
+    if (line) lines.push(line);
+    return lines.slice(0, BUBBLE_MAX_LINES);
+  }
+
+  /** Render a speech bubble as an array of strings */
+  function renderBubble(text, width) {
+    const innerW = width - 4; // │ + space + text + space + │
+    const wrapped = wrapText(text, innerW);
+    const lines = [];
+    lines.push('  \x1b[0m╭' + '─'.repeat(innerW + 2) + '╮');
+    for (const wl of wrapped) {
+      lines.push('  \x1b[0m│ ' + wl + ' '.repeat(innerW - wl.length) + ' │');
+    }
+    // Pad remaining bubble lines if fewer than max
+    for (let i = wrapped.length; i < BUBBLE_MAX_LINES; i++) {
+      lines.push('  \x1b[0m│' + ' '.repeat(innerW + 2) + '│');
+    }
+    lines.push('  \x1b[0m╰' + '─'.repeat(innerW + 2) + '╯');
+    return lines;
+  }
+
+  // Estimate sprite width from first frame of idle animation
+  const spriteWidth = (() => {
+    const firstLine = idleData.frames[0]?.[0] || '';
+    // Strip ANSI escape sequences to get visible character count
+    return firstLine.replace(/\x1b\[[0-9;]*m/g, '').length;
+  })();
+  const bubbleWidth = Math.max(20, Math.min(spriteWidth, 60));
+
+  function drawFrame(idx) {
+    let out = fullscreen ? '\x1b[H' : '\x1b8'; // cursor home vs restore
+    const frameLines = currentFrames[idx] || [];
+    for (let i = 0; i < maxLines; i++) {
+      if (i < frameLines.length) {
+        out += frameLines[i];
+      }
+      out += '\x1b[K\n';
+    }
+
+    // Auto-clear speech after timeout
+    if (speechText && (Date.now() - speechSetAt > SPEECH_CLEAR_MS)) {
+      speechText = null;
+    }
+
+    // Speech bubble or empty space
+    if (speechText) {
+      const bubble = renderBubble(speechText, bubbleWidth);
+      for (const bl of bubble) {
+        out += bl + '\x1b[K\n';
+      }
+    } else {
+      // Empty lines to keep layout stable
+      for (let i = 0; i < bubbleLines - 1; i++) {
+        out += '\x1b[K\n';
+      }
+    }
+
+    // Status line
+    const stateStr = stateEngine.active
+      ? '  ' + Object.entries(stateEngine.toJSON()).map(([k, v]) => `${k.slice(0,3)}:${v}`).join(' ')
+      : '';
+    const keyHints = !agent && character && !opts.noAi ? '[a]=AI key [q]=quit' : '[q]=quit';
+    out += `\x1b[0m\x1b[K  ${characterName} [${currentAnimName}]${stateStr}  ${keyHints}\n`;
+    stdout.write(out);
+  }
+
+  // --- Socket server ---
+  const server = createServer((conn) => {
+    let buf = '';
+    conn.on('data', (chunk) => { buf += chunk.toString(); });
+    conn.on('end', () => {
+      // Process each line (usually just one)
+      for (const line of buf.split('\n').filter(Boolean)) {
+        try {
+          const msg = JSON.parse(line);
+          handleEvent(msg);
+        } catch {
+          // Ignore malformed messages
+        }
+      }
+    });
+  });
+
+  server.on('error', (err) => {
+    // If socket already in use, try to recover
+    if (err.code === 'EADDRINUSE') {
+      try { unlinkSync(sockPath); } catch { /* ignore */ }
+      server.listen(sockPath);
+    }
+  });
+
+  server.listen(sockPath);
+
+  function handleEvent(msg) {
+    lastEventTime = Date.now();
+    sleeping = false;
+
+    // Update session context
+    sessionCtx.update(msg);
+
+    // Update state engine
+    stateEngine.update(msg.event);
+
+    // Instant layer: static map (0ms)
+    const mapping = mapEventToAnimation(msg.event, animMap);
+    if (mapping) {
+      switchAnimation(mapping.anim, mapping.type);
+    }
+
+    // State layer: check thresholds (0ms, overrides instant layer)
+    if (stateEngine.active && personality?.animations) {
+      const triggered = stateEngine.checkThresholds(personality.animations);
+      if (triggered && animMap.has(triggered.animName)) {
+        switchAnimation(triggered.animName, triggered.type);
+      }
+    }
+
+    // Speech bubble (static fallback)
+    const speech = pickSpeech(msg.event, lastSpeech);
+    if (speech) {
+      speechText = speech;
+      speechSetAt = Date.now();
+      lastSpeech = speech;
+    }
+
+    // Personality layer: push to LLM agent (debounced, ~3s)
+    if (agent) {
+      const narrated = narrateEvent(msg);
+      agent.pushEvent(
+        { summary: narrated, type: msg.event, tool: msg.tool_name || msg.tool },
+        sessionCtx.toJSON(),
+      );
+    }
+  }
+
+  function cleanup() {
+    if (agent) agent.destroy();
+    if (stdin.isTTY) stdin.setRawMode(false);
+    stdin.removeAllListeners('data');
+    stdin.pause();
+    if (fullscreen) {
+      stdout.write('\x1b[?1049l\x1b[?25h'); // exit alt screen, show cursor
+    } else {
+      stdout.write('\x1b[?25h'); // show cursor
+    }
+    server.close();
+    try { unlinkSync(sockPath); } catch { /* ignore */ }
+  }
+
+  let promptingKey = false;
+
+  async function handleApiKeyPrompt() {
+    if (promptingKey || agent) return;
+    promptingKey = true;
+
+    // Temporarily exit raw mode for readline
+    if (stdin.isTTY) stdin.setRawMode(false);
+    stdin.removeAllListeners('data');
+
+    const key = await promptForApiKey('hotkey');
+
+    // Restore raw mode
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.on('data', handleKey);
+    }
+    promptingKey = false;
+
+    if (key && character) {
+      agent = createAgent(character, [...animMap.keys()], onAgentReaction, agentOpts);
+      if (agent) {
+        speechText = 'AI personality activated!';
+        speechSetAt = Date.now();
+      }
+    }
+  }
+
+  function handleKey(data) {
+    const key = data.toString();
+    if (key === 'q' || key === '\x03') {
+      quit = true;
+    } else if (key === 'a' && !agent && character && !opts.noAi) {
+      handleApiKeyPrompt();
+    }
+  }
+
+  if (stdin.isTTY) {
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on('data', handleKey);
+  }
+
+  return new Promise((resolve) => {
+    const interval = () => 1000 / currentFps;
+
+    function tick() {
+      if (quit) {
+        cleanup();
+        resolve();
+        return;
+      }
+
+      // State engine tick (passive drain over time)
+      stateEngine.tick();
+
+      // State-driven animation check (e.g. energy < 0.15 → sleep)
+      if (stateEngine.active && personality?.animations) {
+        const triggered = stateEngine.checkThresholds(personality.animations);
+        if (triggered && animMap.has(triggered.animName) && currentAnimName !== triggered.animName) {
+          switchAnimation(triggered.animName, triggered.type);
+          sleeping = triggered.animName === SLEEP_ANIM;
+        }
+      }
+
+      // Fallback sleep check (when no state engine or no energy dimension)
+      if (!sleeping) {
+        const idleTime = (Date.now() - lastEventTime) / 1000;
+        if (idleTime >= SLEEP_TIMEOUT_S) {
+          sleeping = true;
+          if (animMap.has(SLEEP_ANIM)) {
+            switchAnimation(SLEEP_ANIM, 'loop');
+          }
+        }
+      }
+
+      drawFrame(frameIdx);
+      frameIdx++;
+
+      if (frameIdx >= currentFrames.length) {
+        loopCount++;
+        frameIdx = 0;
+
+        // One-shot: count down loops, return to idle
+        if (oneShotLoopsRemaining > 0) {
+          oneShotLoopsRemaining--;
+          if (oneShotLoopsRemaining <= 0) {
+            switchAnimation(IDLE_ANIM, 'loop');
+          }
+        }
+      }
+
+      setTimeout(tick, interval());
+    }
+
+    tick();
+
+    // Print socket path so hooks can find it
+    process.stderr.write(`  Socket: ${sockPath}\n`);
+    if (agent) {
+      const modelName = opts.model || 'claude-haiku-4-5';
+      process.stderr.write(`  AI personality: ON (${modelName})\n`);
+    } else if (character && !opts.noAi) {
+      process.stderr.write(`  AI personality: OFF — press [a] to add API key\n`);
+    } else if (opts.noAi) {
+      process.stderr.write(`  AI personality: OFF (--no-ai)\n`);
+    }
+    process.stderr.write(`  Listening for Claude Code events...\n`);
+
+    const sigHandler = () => { quit = true; };
+    process.on('SIGINT', sigHandler);
+    process.on('SIGTERM', sigHandler);
+    process.on('SIGHUP', sigHandler);
+  });
+}
+
 export function showFrame(framesData, info) {
   const frames = framesData.frames;
   if (!frames || frames.length === 0) {