storymode-cli 1.1.2 → 1.2.1

package/src/reactive.mjs

@@ -0,0 +1,442 @@
+/**
+ * Reactive companion: event mapping, narrator, state engine, animation loader.
+ */
+
+/** Animations that play once then return to idle */
+export const ONE_SHOT_ANIMS = new Set([
+  'waving hello',
+]);
+
+/** Default idle animation name */
+export const IDLE_ANIM = 'idle breathing';
+
+/** Sleep animation name */
+export const SLEEP_ANIM = 'falling asleep';
+
+/** Seconds of inactivity before sleep */
+export const SLEEP_TIMEOUT_S = 120;
+
+/**
+ * Static map: hook event → animation name + type.
+ * Key format matches STORYMODE_HOOK_EVENT env var values.
+ */
+export const STATIC_MAP = {
+  SessionStart:           { anim: 'waving hello',                    type: 'one-shot' },
+  UserPromptSubmit:       { anim: 'scratching head while thinking',  type: 'loop' },
+  PostToolUse_action:     { anim: 'casting lightning spell',         type: 'loop' },
+  PostToolUse_research:   { anim: 'scratching head while thinking',  type: 'loop' },
+  PostToolUseFailure:     { anim: 'charging up magical energy',      type: 'loop' },
+  Stop:                   { anim: 'idle breathing',                  type: 'loop' },
+  SessionEnd:             { anim: 'waving hello',                    type: 'one-shot' },
+  SubagentStart:          { anim: 'charging up magical energy',      type: 'one-shot' },
+  SubagentStop:           { anim: 'idle breathing',                  type: 'loop' },
+};
+
+/**
+ * Speech lines per event type. A random one is picked each time.
+ * null = no speech (stay quiet).
+ */
+export const SPEECH_MAP = {
+  SessionStart:         ['Hey there!', 'Ready to code!', "Let's go~", 'Hi hi!', 'Oh, hello!'],
+  UserPromptSubmit:     ['Hmm...', 'Interesting...', 'Ooh, a challenge!', 'Let me think...', null, null],
+  PostToolUse_action:   ['Nice!', 'Zap!', 'Code go brrr~', null, null, null],
+  PostToolUse_research: ['Looking...', 'Where is it...', null, null, null, null],
+  PostToolUseFailure:   ['Oof!', 'That stings...', "We'll fix it!", 'Ouch!', 'Ow ow ow'],
+  Stop:                 ['Done!', 'All yours~', null, null],
+  SessionEnd:           ['Bye bye!', 'See ya~', 'Good session!'],
+  SubagentStart:        ['Reinforcements!', 'A friend!', 'Backup arriving~'],
+  SubagentStop:         ['And they vanish...', 'Back to us~', null],
+};
+
+/** Pick a random speech line for an event, avoiding the last spoken line */
+export function pickSpeech(eventType, lastSpeech) {
+  const lines = SPEECH_MAP[eventType];
+  if (!lines || lines.length === 0) return null;
+  // Try up to 3 times to avoid repeating
+  for (let i = 0; i < 3; i++) {
+    const pick = lines[Math.floor(Math.random() * lines.length)];
+    if (pick !== lastSpeech) return pick;
+  }
+  return lines[Math.floor(Math.random() * lines.length)];
+}
+
+/**
+ * Instant-layer lookup: event string → { anim, type } or null.
+ * Falls back gracefully if the animation doesn't exist in the loaded set.
+ */
+export function mapEventToAnimation(eventType, availableAnims) {
+  const mapping = STATIC_MAP[eventType];
+  if (!mapping) return null;
+  // If the target animation isn't available, fall back to idle
+  if (availableAnims && !availableAnims.has(mapping.anim)) {
+    if (mapping.anim === IDLE_ANIM) return null; // already idle
+    return { anim: IDLE_ANIM, type: 'loop' };
+  }
+  return mapping;
+}
+
+/**
+ * Narrate a raw hook event into a 1-line human-readable summary.
+ * Used for future LLM context (Phase 2).
+ */
+export function narrateEvent(msg) {
+  const { event } = msg;
+
+  if (event === 'SessionStart') return 'Session started';
+  if (event === 'SessionEnd') return 'Session ended';
+  if (event === 'SubagentStart') return 'Sub-agent spawned';
+  if (event === 'SubagentStop') return 'Sub-agent finished';
+  if (event === 'Stop') return 'Claude stopped generating';
+
+  if (event === 'UserPromptSubmit') {
+    const prompt = msg.prompt || msg.tool_input?.prompt;
+    if (prompt) {
+      const short = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt;
+      return `User asked: '${short}'`;
+    }
+    return 'User submitted a prompt';
+  }
+
+  if (event === 'PostToolUseFailure') {
+    const tool = msg.tool_name || msg.tool || 'unknown tool';
+    return `${tool} failed`;
+  }
+
+  // PostToolUse_action or PostToolUse_research
+  if (event?.startsWith('PostToolUse')) {
+    const tool = msg.tool_name || msg.tool || '';
+    const input = msg.tool_input || {};
+
+    if (tool === 'Bash') {
+      const cmd = input.command || '';
+      const short = cmd.length > 60 ? cmd.slice(0, 57) + '...' : cmd;
+      return `Ran \`${short}\``;
+    }
+    if (tool === 'Edit' || tool === 'Write') {
+      const file = (input.file_path || '').split('/').pop() || 'a file';
+      return `Edited ${file}`;
+    }
+    if (tool === 'Read') {
+      const file = (input.file_path || '').split('/').pop() || 'a file';
+      return `Read ${file}`;
+    }
+    if (tool === 'Grep') {
+      const pattern = input.pattern || '';
+      return `Searched for '${pattern}'`;
+    }
+    if (tool === 'Glob') {
+      const pattern = input.pattern || '';
+      return `Searched files: ${pattern}`;
+    }
+    return `Used ${tool}`;
+  }
+
+  return `Event: ${event || 'unknown'}`;
+}
+
+/**
+ * Session context — tracks accumulated stats for LLM context (Phase 2).
+ */
+export class SessionContext {
+  constructor() {
+    this.startedAt = Date.now();
+    this.toolCount = 0;
+    this.errorCount = 0;
+    this.filesTouched = new Set();
+    this.currentActivity = 'idle';
+  }
+
+  update(msg) {
+    const { event } = msg;
+    if (event?.startsWith('PostToolUse')) {
+      this.toolCount++;
+      const file = msg.tool_input?.file_path;
+      if (file) this.filesTouched.add(file.split('/').pop());
+      this.currentActivity = event.includes('research') ? 'researching' : 'coding';
+    }
+    if (event === 'PostToolUseFailure') {
+      this.errorCount++;
+      this.currentActivity = 'debugging';
+    }
+    if (event === 'UserPromptSubmit') {
+      this.currentActivity = 'thinking';
+    }
+  }
+
+  toJSON() {
+    return {
+      duration_s: Math.round((Date.now() - this.startedAt) / 1000),
+      tool_count: this.toolCount,
+      error_count: this.errorCount,
+      files_touched: [...this.filesTouched].slice(-10),
+      current_activity: this.currentActivity,
+    };
+  }
+}
+
+// --- State Engine ---
+
+/**
+ * Parse prose descriptions for rate keywords.
+ * Returns a magnitude (0-1 scale per event/tick).
+ */
+function parseRate(prose) {
+  if (!prose) return 0.06;
+  const lower = prose.toLowerCase();
+  if (/spike|hard|enormous|catastrophic|dramatic/.test(lower)) return 0.18;
+  if (/fast|quick|rapid|immediate/.test(lower)) return 0.12;
+  if (/slow|glacial|barely|steady|small/.test(lower)) return 0.03;
+  if (/moderate|gradual/.test(lower)) return 0.06;
+  return 0.06;
+}
+
+/**
+ * Keyword → category mapping for trigger extraction.
+ */
+const TRIGGER_KEYWORDS = [
+  [/\b(?:error|fail|wrong|broke|stings)\b/, 'error'],
+  [/\b(?:success|complete|done|finish|overcome|solved)\b/, 'success'],
+  [/\b(?:idle|silence|bored|quiet|nothing|waiting|still)\b/, 'idle'],
+  [/\b(?:over time|constant|always|even when|exhaust|deplete)\b/, 'time'],
+  [/\b(?:any event|anything|everything|any activity|always happen|wake)\b/, 'any'],
+  [/\b(?:novel|interesting|curious)\b/, 'novel'],
+  [/\b(?:sloppy|messy|hasty|rush)\b/, 'sloppy'],
+  [/\b(?:craft|clean|thought|careful|proper|organiz)/, 'craft'],
+  [/\b(?:praise|liked|respect)\b/, 'praise'],
+  [/\b(?:repeat|again|compound|stack|pile|sustain|streak)\b/, 'repeat'],
+];
+
+/**
+ * Parse prose descriptions for event-type triggers.
+ *
+ * @param {string} prose
+ * @param {'drain'|'restore'} fieldType - Which field this prose comes from
+ * @returns {{ positive: string[], negative: string[] }}
+ *   positive: triggers that act in the field's expected direction
+ *   negative: triggers in the OPPOSITE direction (e.g. "clean refactors lower it" in a restore field)
+ */
+function parseTriggers(prose, fieldType) {
+  if (!prose) return { positive: [], negative: [] };
+
+  // Split into clauses on sentence boundaries
+  const clauses = prose.toLowerCase().split(/[.;!]\s*|\s+but\s+/);
+  const positive = new Set();
+  const negative = new Set();
+
+  for (const clause of clauses) {
+    if (!clause.trim()) continue;
+
+    // Only detect contradictions in restore fields:
+    // "clean refactors lower it" in a restore field → clean is actually a drain trigger
+    // In drain fields, decrease-words just confirm the field direction, not negate it
+    const isContradiction = fieldType === 'restore'
+      && /\blower|reduce|drop|decrease|diminish\b/.test(clause);
+
+    for (const [pattern, category] of TRIGGER_KEYWORDS) {
+      if (pattern.test(clause)) {
+        if (isContradiction) {
+          negative.add(category);
+        } else {
+          positive.add(category);
+        }
+      }
+    }
+  }
+
+  return { positive: [...positive], negative: [...negative] };
+}
+
+/**
+ * Parse a "when" condition like "< 0.15" or "> 0.8" into a test function.
+ */
+function parseCondition(condStr) {
+  const match = condStr.match(/^\s*(>=?|<=?)\s*([\d.]+)\s*$/);
+  if (!match) return null;
+  const op = match[1];
+  const val = parseFloat(match[2]);
+  if (op === '<') return (v) => v < val;
+  if (op === '<=') return (v) => v <= val;
+  if (op === '>') return (v) => v > val;
+  if (op === '>=') return (v) => v >= val;
+  return null;
+}
+
+/**
+ * Categorize a raw hook event into abstract categories for state matching.
+ * Categories match the keywords extracted by parseTriggers().
+ */
+function categorizeEvent(eventType) {
+  const cats = new Set();
+  cats.add('any');
+  if (eventType === 'PostToolUseFailure') {
+    cats.add('error');
+    cats.add('sloppy'); // errors can be seen as sloppy work
+  } else if (eventType === 'Stop') {
+    cats.add('success');
+    cats.add('craft');
+  } else if (eventType?.startsWith('PostToolUse')) {
+    cats.add('success');
+    cats.add('activity');
+    cats.add('craft');
+  } else if (eventType === 'UserPromptSubmit') {
+    cats.add('novel');
+    cats.add('activity');
+  } else if (eventType === 'SessionStart') {
+    cats.add('success');
+  }
+  return cats;
+}
+
+/**
+ * State engine — tracks internal dimensions over time based on disposition.
+ *
+ * @param {object} stateConfig - disposition.state from personality.json
+ *   e.g. { energy: { initial: 0.8, drain: "...", restore: "..." }, ... }
+ */
+export class StateEngine {
+  constructor(stateConfig) {
+    this.values = {};
+    this.config = {};
+    this.lastTickTime = Date.now();
+    this.consecutiveErrors = 0;
+    this.consecutiveSuccesses = 0;
+
+    if (!stateConfig) return;
+
+    for (const [name, cfg] of Object.entries(stateConfig)) {
+      this.values[name] = cfg.initial ?? 0.5;
+
+      const drainParsed = parseTriggers(cfg.drain, 'drain');
+      const restoreParsed = parseTriggers(cfg.restore, 'restore');
+
+      this.config[name] = {
+        drainRate: parseRate(cfg.drain),
+        restoreRate: parseRate(cfg.restore),
+        // Drain triggers: positive from drain field + negated from restore field
+        drainTriggers: [...drainParsed.positive, ...restoreParsed.negative],
+        // Restore triggers: positive from restore field + negated from drain field
+        restoreTriggers: [...restoreParsed.positive, ...drainParsed.negative],
+        // Time-based drain flag
+        hasTimeDrain: drainParsed.positive.includes('time') || drainParsed.positive.includes('idle'),
+      };
+    }
+  }
+
+  /** Returns true if this engine has any dimensions to track. */
+  get active() {
+    return Object.keys(this.config).length > 0;
+  }
+
+  /**
+   * Update state based on an event.
+   * @param {string} eventType - Raw hook event type (e.g. 'PostToolUseFailure')
+   */
+  update(eventType) {
+    if (!this.active) return;
+
+    // Track streaks
+    if (eventType === 'PostToolUseFailure') {
+      this.consecutiveErrors++;
+      this.consecutiveSuccesses = 0;
+    } else if (eventType?.startsWith('PostToolUse') || eventType === 'Stop') {
+      this.consecutiveSuccesses++;
+      this.consecutiveErrors = 0;
+    }
+
+    const cats = categorizeEvent(eventType);
+    const repeatMultiplier = cats.has('error')
+      ? Math.min(1 + this.consecutiveErrors * 0.3, 2.5)
+      : cats.has('success')
+        ? Math.min(1 + this.consecutiveSuccesses * 0.2, 2.0)
+        : 1;
+
+    for (const [name, cfg] of Object.entries(this.config)) {
+      let delta = 0;
+
+      // Check restore triggers (things that INCREASE this dimension)
+      const restoreMatch = cfg.restoreTriggers.some(t => cats.has(t));
+      if (restoreMatch) {
+        delta += cfg.restoreRate * repeatMultiplier;
+      }
+
+      // Check drain triggers (things that DECREASE this dimension), excluding time-based
+      const drainMatch = cfg.drainTriggers.some(t => cats.has(t) && t !== 'time' && t !== 'idle');
+      if (drainMatch) {
+        delta -= cfg.drainRate * repeatMultiplier;
+      }
+
+      this.values[name] = Math.max(0, Math.min(1, this.values[name] + delta));
+    }
+  }
+
+  /**
+   * Time-based tick — applies passive drain/restore.
+   * Call this periodically (e.g. every 5 seconds).
+   */
+  tick() {
+    if (!this.active) return;
+
+    const now = Date.now();
+    const elapsed = (now - this.lastTickTime) / 1000;
+    this.lastTickTime = now;
+
+    // Scale changes by time elapsed (normalized to 10s intervals)
+    const scale = elapsed / 10;
+
+    for (const [name, cfg] of Object.entries(this.config)) {
+      let delta = 0;
+
+      // Time-based drain
+      if (cfg.hasTimeDrain) {
+        delta -= cfg.drainRate * scale;
+      }
+
+      // Passive decay toward 0 for dimensions without event-based drain triggers.
+      // Uses the parsed drain rate so "evaporates quickly" decays faster than "slow decay."
+      if (!cfg.hasTimeDrain && cfg.drainTriggers.length === 0 && this.values[name] > 0) {
+        delta -= cfg.drainRate * scale;
+      }
+
+      if (delta !== 0) {
+        this.values[name] = Math.max(0, Math.min(1, this.values[name] + delta));
+      }
+    }
+  }
+
+  /**
+   * Check animation `when` conditions against current state.
+   * Returns the first matching animation role, or null.
+   *
+   * @param {object} animations - animations section from personality.json
+   *   Structure: { set: { role: { name, type, when? } } }
+   * @returns {{ animName: string, type: string } | null}
+   */
+  checkThresholds(animations) {
+    if (!this.active || !animations) return null;
+
+    for (const set of Object.values(animations)) {
+      for (const [, entry] of Object.entries(set)) {
+        if (!entry.when) continue;
+        let allMatch = true;
+        for (const [dim, condStr] of Object.entries(entry.when)) {
+          if (!(dim in this.values)) { allMatch = false; break; }
+          const test = parseCondition(condStr);
+          if (!test || !test(this.values[dim])) { allMatch = false; break; }
+        }
+        if (allMatch) {
+          return { animName: entry.name, type: entry.type || 'loop' };
+        }
+      }
+    }
+    return null;
+  }
+
+  /** Current state as a plain object. */
+  toJSON() {
+    const out = {};
+    for (const [k, v] of Object.entries(this.values)) {
+      out[k] = Math.round(v * 100) / 100;
+    }
+    return out;
+  }
+}