storymode-cli 1.2.0 → 1.2.2

package/src/reactive.mjs

@@ -1,6 +1,5 @@
 /**
- * Reactive companion: event mapping, narrator, animation loader.
- * Phase 1 — static map only (no LLM).
+ * Reactive companion: event mapping, narrator, state engine, animation loader.
  */
 
 /** Animations that play once then return to idle */
@@ -174,3 +173,270 @@ export class SessionContext {
     };
   }
 }
+
+// --- 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;
+  }
+}