@vsuryav/agent-sim 0.1.0

package/src/engine/stubs/bootstrap-state.ts

@@ -0,0 +1,4 @@
+// Stub for src/bootstrap/state.js — telemetry we don't need
+export function flushInteractionTime(): void {
+  // no-op: Agent Sim doesn't track interaction telemetry
+}

package/src/engine/stubs/debug.ts

@@ -0,0 +1,6 @@
+// Stub for src/utils/debug.js
+export function logForDebugging(..._args: unknown[]): void {
+  if (process.env.AGENT_SIM_DEBUG || process.env.AGENT_WARS_DEBUG) {
+    console.error("[agent-sim debug]", ..._args);
+  }
+}

package/src/engine/stubs/log.ts

@@ -0,0 +1,4 @@
+// Stub for src/utils/log.js
+export function logError(...args: unknown[]): void {
+  console.error("[agent-sim]", ...args);
+}

package/src/engine/utils/debug.ts

@@ -0,0 +1,5 @@
+export function logForDebugging(..._args: unknown[]): void {
+  if (process.env.AGENT_SIM_DEBUG || process.env.AGENT_WARS_DEBUG) {
+    console.error('[agent-sim debug]', ..._args);
+  }
+}

package/src/engine/utils/earlyInput.ts

@@ -0,0 +1,4 @@
+// Stub — the host runtime can capture early stdin before React mounts
+export function stopCapturingEarlyInput(): Buffer[] {
+  return [];
+}

package/src/engine/utils/env.ts

@@ -0,0 +1,15 @@
+// Terminal environment detection stub
+export const env = {
+  terminal: detectTerminal(),
+  isTTY: process.stdout.isTTY ?? false,
+};
+
+function detectTerminal(): string {
+  const term = process.env.TERM_PROGRAM?.toLowerCase() ?? '';
+  if (term.includes('kitty')) return 'kitty';
+  if (term.includes('iterm')) return 'iterm2';
+  if (term.includes('wezterm')) return 'wezterm';
+  if (term.includes('alacritty')) return 'alacritty';
+  if (term.includes('vscode')) return 'vscode';
+  return term || 'unknown';
+}

package/src/engine/utils/envUtils.ts

@@ -0,0 +1,4 @@
+export function isEnvTruthy(key: string): boolean {
+  const val = process.env[key];
+  return val === '1' || val === 'true';
+}

package/src/engine/utils/execFileNoThrow.ts

@@ -0,0 +1,24 @@
+// Stub for exec utility used in clipboard operations
+import { execFile as execFileCb } from 'child_process';
+
+interface ExecResult {
+  code: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+export function execFileNoThrow(
+  cmd: string,
+  args: string[],
+  opts: { input?: string; timeout?: number } = {},
+): Promise<ExecResult> {
+  return new Promise(resolve => {
+    const child = execFileCb(cmd, args, { timeout: opts.timeout ?? 5000 }, (err, stdout, stderr) => {
+      resolve({ code: err ? (err as any).code ?? 1 : 0, stdout: stdout ?? '', stderr: stderr ?? '' });
+    });
+    if (opts.input && child.stdin) {
+      child.stdin.write(opts.input);
+      child.stdin.end();
+    }
+  });
+}

package/src/engine/utils/fullscreen.ts

@@ -0,0 +1,4 @@
+// Stub — fullscreen support is delegated to the host runtime
+export function isMouseClicksDisabled(): boolean {
+  return false;
+}

package/src/engine/utils/intl.ts

@@ -0,0 +1,9 @@
+// Grapheme segmenter utility
+let segmenter: Intl.Segmenter | null = null;
+
+export function getGraphemeSegmenter(): Intl.Segmenter {
+  if (!segmenter) {
+    segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+  }
+  return segmenter;
+}

package/src/engine/utils/log.ts

@@ -0,0 +1,3 @@
+export function logError(...args: unknown[]): void {
+  console.error('[agent-sim]', ...args);
+}

package/src/engine/utils/semver.ts

@@ -0,0 +1,13 @@
+// Minimal semver comparison stub
+export function gte(version: string, range: string): boolean {
+  const parse = (v: string) => v.split('.').map(Number);
+  const a = parse(version);
+  const b = parse(range);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return true;
+}

package/src/engine/utils/sliceAnsi.ts

@@ -0,0 +1,10 @@
+// ANSI-aware string slicing
+import stripAnsi from 'strip-ansi';
+
+export default function sliceAnsi(text: string, start: number, end?: number): string {
+  const stripped = stripAnsi(text);
+  const sliced = stripped.slice(start, end);
+  // Simple version: just return the stripped slice
+  // Full version would preserve ANSI codes, but this works for our use case
+  return sliced;
+}

package/src/engine/utils/theme.ts

@@ -0,0 +1,17 @@
+// Minimal theme stub for buddy sprite compatibility
+export interface Theme {
+  inactive: string;
+  success: string;
+  permission: string;
+  autoAccept: string;
+  warning: string;
+  [key: string]: string;
+}
+
+export const defaultTheme: Theme = {
+  inactive: '#666666',
+  success: '#44cc44',
+  permission: '#4488ff',
+  autoAccept: '#ff44aa',
+  warning: '#ffcc44',
+};

package/src/game/App.tsx

@@ -0,0 +1,141 @@
+// Main game shell. Wraps everything in AlternateScreen.
+// Manages: view state, agent selection, simulation loop, keyboard input.
+
+import React, { useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { AlternateScreen } from '../engine/ink/components/AlternateScreen.js';
+import Box from '../engine/ink/components/Box.js';
+import Text from '../engine/ink/components/Text.js';
+import { TerminalSizeContext } from '../engine/ink/components/TerminalSizeContext.js';
+import { generateShip } from './ship/ship-map.js';
+import { ShipView } from './ship/ShipView.js';
+import { createAgentSim, tickAgent, type AgentSim } from './agents/behavior.js';
+import { HUD } from './ui/HUD.js';
+import { StatusBar } from './ui/StatusBar.js';
+import { AgentBio } from './ui/AgentBio.js';
+import { useKeyboard } from './useKeyboard.js';
+
+type View = 'ship' | 'bio';
+
+interface AgentRow {
+  id: string;
+  name: string;
+  clan: string;
+  maturity: string;
+  trait_builder: number;
+  trait_creator: number;
+  trait_explorer: number;
+  trait_leader: number;
+  trait_thinker: number;
+  trait_scholar: number;
+}
+
+interface GameProps {
+  agents: AgentRow[];
+  clans: Array<{ name: string; color: string }>;
+  phase: string;
+  day: number;
+  seed: number;
+  onQuit: () => void;
+}
+
+export function GameApp({ agents: agentRows, clans, phase, day, seed, onQuit }: GameProps): React.ReactNode {
+  const size = useContext(TerminalSizeContext);
+  const cols = size?.columns ?? 80;
+  const rows = size?.rows ?? 24;
+
+  const ship = useMemo(() => generateShip(agentRows.length), [agentRows.length]);
+
+  // Agent sims (mutable)
+  const agentSimsRef = useRef<AgentSim[]>([]);
+  if (agentSimsRef.current.length === 0) {
+    const clanNames = [...new Set(agentRows.map(a => a.clan))];
+    agentSimsRef.current = agentRows.map((a, i) => {
+      const clanIdx = clanNames.indexOf(a.clan);
+      const spawn = ship.spawnPoints[i % ship.spawnPoints.length]!;
+      return createAgentSim(a, spawn.x, spawn.y, clanIdx, seed);
+    });
+  }
+
+  const [view, setView] = useState<View>('ship');
+  const [selectedIdx, setSelectedIdx] = useState(0);
+  const [paused, setPaused] = useState(false);
+
+  const selectedAgent = agentSimsRef.current[selectedIdx % agentSimsRef.current.length] ?? null;
+
+  // Simulation loop (10Hz)
+  const pausedRef = useRef(paused);
+  pausedRef.current = paused;
+  useEffect(() => {
+    const interval = setInterval(() => {
+      if (pausedRef.current) return;
+      const agents = agentSimsRef.current;
+      for (const agent of agents) {
+        tickAgent(agent, ship, agents);
+      }
+    }, 100);
+    return () => clearInterval(interval);
+  }, [ship]);
+
+  // Keyboard
+  useKeyboard((event) => {
+    if (event.key === 'q' || (event.ctrl && event.key === 'c')) {
+      onQuit();
+      return;
+    }
+    if (event.tab) {
+      setSelectedIdx(i => (i + 1) % Math.max(1, agentSimsRef.current.length));
+      return;
+    }
+    if (event.space) {
+      setPaused(p => !p);
+      return;
+    }
+    if (event.key === 'b') {
+      setView(v => v === 'bio' ? 'ship' : 'bio');
+      return;
+    }
+    if (event.escape) {
+      setView('ship');
+      return;
+    }
+  });
+
+  const viewHeight = rows - 2;
+  const viewWidth = cols;
+
+  return (
+    <AlternateScreen mouseTracking={false}>
+      <Box flexDirection="column" width="100%" height={rows}>
+        <HUD
+          phase={phase}
+          agentCount={agentSimsRef.current.length}
+          clanCount={clans.length}
+          day={day}
+          selectedAgent={selectedAgent}
+          paused={paused}
+        />
+
+        {view === 'ship' ? (
+          <ShipView
+            ship={ship}
+            agents={agentSimsRef.current}
+            viewWidth={viewWidth}
+            viewHeight={viewHeight}
+            seed={seed}
+            selectedAgentId={selectedAgent?.id ?? null}
+            paused={paused}
+          />
+        ) : view === 'bio' && selectedAgent ? (
+          <AgentBio
+            agent={selectedAgent}
+            onClose={() => setView('ship')}
+          />
+        ) : (
+          <Box flexGrow={1} />
+        )}
+
+        <StatusBar view={view} />
+      </Box>
+    </AlternateScreen>
+  );
+}

package/src/game/agents/behavior.ts

@@ -0,0 +1,249 @@
+// Agent autonomous behavior state machine.
+// Each agent has a state, energy, and target position.
+// Behavior selection is weighted by personality traits from real coding sessions.
+
+import { createSeededRandom, hashString } from '@vsuryav/agent-sim-core';
+import type { ShipLayout } from '../ship/ship-map.js';
+
+export type AgentState = 'idle' | 'walking' | 'sleeping' | 'chatting' | 'working' | 'exploring';
+
+export interface AgentSim {
+  id: string;
+  name: string;
+  clan: string;
+  maturity: string;
+  // Position (world coordinates)
+  x: number;
+  y: number;
+  // Smooth animation position (lerps toward x,y)
+  renderX: number;
+  renderY: number;
+  // State machine
+  state: AgentState;
+  stateTimer: number; // ticks remaining in current state
+  targetX: number;
+  targetY: number;
+  // Stats
+  energy: number; // 0-100
+  // Personality (from real data)
+  traits: {
+    builder: number;
+    creator: number;
+    explorer: number;
+    leader: number;
+    thinker: number;
+    scholar: number;
+  };
+  // Visual
+  color: string;
+  sprite: string; // 1-2 char display
+  // Speech
+  speech: string | null;
+  speechTimer: number;
+  // Animation
+  facing: 'left' | 'right';
+  animFrame: number;
+}
+
+// Clan colors palette
+const CLAN_COLORS = [
+  '#ff6b6b', '#ffd93d', '#6bcb77', '#4d96ff',
+  '#c084fc', '#fb7185', '#38bdf8', '#a3e635',
+  '#f472b6', '#facc15', '#34d399', '#60a5fa',
+];
+
+// Maturity sprites
+const MATURITY_SPRITES: Record<string, string> = {
+  spark:   '·',
+  newborn: 'o',
+  worker:  '☺',
+  elder:   '♦',
+  legend:  '★',
+};
+
+export function createAgentSim(
+  agent: {
+    id: string; name: string; clan: string; maturity: string;
+    trait_builder: number; trait_creator: number; trait_explorer: number;
+    trait_leader: number; trait_thinker: number; trait_scholar: number;
+  },
+  spawnX: number,
+  spawnY: number,
+  clanIndex: number,
+  worldSeed: number,
+): AgentSim {
+  const rand = createSeededRandom(hashString(`${worldSeed}:${agent.id}`));
+  return {
+    id: agent.id,
+    name: agent.name,
+    clan: agent.clan,
+    maturity: agent.maturity,
+    x: spawnX,
+    y: spawnY,
+    renderX: spawnX,
+    renderY: spawnY,
+    state: 'idle',
+    stateTimer: 20 + Math.floor(rand() * 40),
+    targetX: spawnX,
+    targetY: spawnY,
+    energy: 80 + Math.floor(rand() * 20),
+    traits: {
+      builder: agent.trait_builder,
+      creator: agent.trait_creator,
+      explorer: agent.trait_explorer,
+      leader: agent.trait_leader,
+      thinker: agent.trait_thinker,
+      scholar: agent.trait_scholar,
+    },
+    color: CLAN_COLORS[clanIndex % CLAN_COLORS.length]!,
+    sprite: MATURITY_SPRITES[agent.maturity] ?? '☺',
+    speech: null,
+    speechTimer: 0,
+    facing: rand() > 0.5 ? 'right' : 'left',
+    animFrame: 0,
+  };
+}
+
+// Pick a random walkable position on the ship
+function randomWalkable(ship: ShipLayout): { x: number; y: number } {
+  if (ship.spawnPoints.length === 0) return { x: 0, y: 0 };
+  return ship.spawnPoints[Math.floor(Math.random() * ship.spawnPoints.length)]!;
+}
+
+// Select next behavior based on personality traits
+function pickBehavior(agent: AgentSim): AgentState {
+  const t = agent.traits;
+  const tired = (100 - agent.energy) / 100;
+
+  const weights: Array<[AgentState, number]> = [
+    ['working',   (t.builder + t.creator) * 0.3],
+    ['exploring', t.explorer * 0.25],
+    ['chatting',  t.leader * 0.2],
+    ['idle',      t.thinker * 0.15 + 0.1],
+    ['sleeping',  tired * 0.4],
+  ];
+
+  // Sparks and newborns sleep more
+  if (agent.maturity === 'spark' || agent.maturity === 'newborn') {
+    weights.push(['sleeping', 0.3]);
+  }
+
+  const total = weights.reduce((sum, [, w]) => sum + w, 0);
+  let roll = Math.random() * total;
+  for (const [state, weight] of weights) {
+    roll -= weight;
+    if (roll <= 0) return state;
+  }
+  return 'idle';
+}
+
+// Tick agent behavior (called at 10Hz simulation rate)
+export function tickAgent(agent: AgentSim, ship: ShipLayout, allAgents: AgentSim[]): void {
+  agent.stateTimer--;
+  agent.animFrame++;
+
+  // Drain energy slowly
+  if (agent.state !== 'sleeping') {
+    agent.energy = Math.max(0, agent.energy - 0.1);
+  }
+
+  // Clear expired speech
+  if (agent.speechTimer > 0) {
+    agent.speechTimer--;
+    if (agent.speechTimer <= 0) {
+      agent.speech = null;
+    }
+  }
+
+  // State-specific behavior
+  switch (agent.state) {
+    case 'walking': {
+      // Move toward target
+      const dx = agent.targetX - agent.x;
+      const dy = agent.targetY - agent.y;
+      if (Math.abs(dx) + Math.abs(dy) <= 1) {
+        // Arrived at target
+        agent.x = agent.targetX;
+        agent.y = agent.targetY;
+        agent.state = 'idle';
+        agent.stateTimer = 10 + Math.floor(Math.random() * 20);
+      } else {
+        // Step toward target (one tile per tick)
+        if (Math.abs(dx) > Math.abs(dy)) {
+          const nextX = agent.x + Math.sign(dx);
+          const tile = ship.tiles[agent.y]?.[nextX];
+          if (tile === 'floor' || tile === 'door') {
+            agent.x = nextX;
+            agent.facing = dx > 0 ? 'right' : 'left';
+          }
+        } else {
+          const nextY = agent.y + Math.sign(dy);
+          const tile = ship.tiles[nextY]?.[agent.x];
+          if (tile === 'floor' || tile === 'door') {
+            agent.y = nextY;
+          }
+        }
+      }
+      break;
+    }
+
+    case 'sleeping':
+      agent.energy = Math.min(100, agent.energy + 0.5);
+      if (agent.energy >= 95 || agent.stateTimer <= 0) {
+        agent.state = 'idle';
+        agent.stateTimer = 5;
+      }
+      break;
+
+    case 'chatting': {
+      // Look for nearby agent to face
+      const nearby = allAgents.find(
+        a => a.id !== agent.id &&
+          Math.abs(a.x - agent.x) <= 2 && Math.abs(a.y - agent.y) <= 2
+      );
+      if (nearby) {
+        agent.facing = nearby.x > agent.x ? 'right' : 'left';
+      }
+      if (agent.stateTimer <= 0) {
+        agent.state = 'idle';
+        agent.stateTimer = 10;
+      }
+      break;
+    }
+
+    default:
+      // idle, working, exploring — wait out timer
+      if (agent.stateTimer <= 0) {
+        // Pick next behavior
+        const next = pickBehavior(agent);
+        agent.state = next;
+
+        if (next === 'walking' || next === 'exploring') {
+          const target = randomWalkable(ship);
+          agent.targetX = target.x;
+          agent.targetY = target.y;
+          agent.state = 'walking';
+          agent.stateTimer = 100;
+        } else if (next === 'chatting') {
+          agent.stateTimer = 20 + Math.floor(Math.random() * 30);
+        } else if (next === 'sleeping') {
+          agent.stateTimer = 40 + Math.floor(Math.random() * 60);
+        } else if (next === 'working') {
+          agent.stateTimer = 20 + Math.floor(Math.random() * 30);
+        } else {
+          agent.stateTimer = 15 + Math.floor(Math.random() * 25);
+        }
+      }
+      break;
+  }
+}
+
+// Smooth render position toward actual position (called at 60Hz)
+export function lerpAgent(agent: AgentSim, dt: number): void {
+  const speed = 0.15;
+  agent.renderX += (agent.x - agent.renderX) * speed;
+  agent.renderY += (agent.y - agent.renderY) * speed;
+  // Snap when very close
+  if (Math.abs(agent.x - agent.renderX) < 0.05) agent.renderX = agent.x;
+  if (Math.abs(agent.y - agent.renderY) < 0.05) agent.renderY = agent.y;
+}

package/src/game/agents/speech.ts

@@ -0,0 +1,57 @@
+// Cute gibberish speech bubble generator for agent chatter.
+// Agents speak in nonsense syllables that feel whimsical.
+
+const SYLLABLES = [
+  'bip', 'bop', 'blip', 'blorp', 'pip', 'pop', 'pew',
+  'zip', 'zap', 'zorp', 'nib', 'nub', 'mip', 'mop',
+  'fwee', 'twee', 'doot', 'toot', 'beep', 'boop',
+  'wub', 'dub', 'flop', 'plip', 'glub', 'squee',
+  'eep', 'oop', 'yip', 'yap', 'chirp', 'burp',
+];
+
+const EMOTES = ['!', '?', '~', '...', '!!', '?!', '♪', '♥', '✦', '☆'];
+
+const GREETINGS = [
+  'hi hi!', 'henlo~', 'ohai!', '*wave*', 'yooo~',
+];
+
+const EXCLAMATIONS = [
+  '*gasp*', 'ooh!', 'wow~', 'neat!', 'hehe~', 'whoa!', 'hmm...',
+  '*yawn*', 'zzz...', '*stretch*', '*hum*', '♪♫♪',
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)]!;
+}
+
+export function generateSpeech(): string {
+  const roll = Math.random();
+
+  if (roll < 0.2) {
+    // Greeting
+    return pick(GREETINGS);
+  }
+  if (roll < 0.4) {
+    // Exclamation
+    return pick(EXCLAMATIONS);
+  }
+  if (roll < 0.7) {
+    // Gibberish sentence (2-3 syllables + emote)
+    const count = 2 + Math.floor(Math.random() * 2);
+    const words = Array.from({ length: count }, () => pick(SYLLABLES));
+    return words.join(' ') + pick(EMOTES);
+  }
+  // Single emote
+  return pick(EMOTES);
+}
+
+// State-specific speech
+export function stateSpeech(state: string): string | null {
+  switch (state) {
+    case 'sleeping': return Math.random() < 0.1 ? 'zzz...' : null;
+    case 'chatting': return Math.random() < 0.4 ? generateSpeech() : null;
+    case 'working': return Math.random() < 0.15 ? pick(['*tap tap*', '*click*', '♪', 'hmm...', '*type type*']) : null;
+    case 'exploring': return Math.random() < 0.1 ? pick(['ooh!', 'what\'s this?', '✦', '*peek*']) : null;
+    default: return Math.random() < 0.05 ? generateSpeech() : null;
+  }
+}

package/src/game/canvas.ts

@@ -0,0 +1,98 @@
+// 2D character buffer for game rendering.
+// Instead of producing ANSI strings, produces structured row data
+// that can be rendered as React Text segments.
+
+export interface Cell {
+  char: string;
+  fg: string;
+  bg: string;
+}
+
+export interface TextSpan {
+  text: string;
+  fg: string;
+  bg: string;
+}
+
+const DEFAULT_FG = '#aaaaaa';
+const DEFAULT_BG = '#111111';
+
+export class Canvas {
+  readonly width: number;
+  readonly height: number;
+  private cells: Cell[][];
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+    this.cells = [];
+    for (let y = 0; y < height; y++) {
+      const row: Cell[] = [];
+      for (let x = 0; x < width; x++) {
+        row.push({ char: ' ', fg: DEFAULT_FG, bg: DEFAULT_BG });
+      }
+      this.cells.push(row);
+    }
+  }
+
+  clear(fg = DEFAULT_FG, bg = DEFAULT_BG): void {
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        const c = this.cells[y]![x]!;
+        c.char = ' ';
+        c.fg = fg;
+        c.bg = bg;
+      }
+    }
+  }
+
+  set(x: number, y: number, char: string, fg?: string, bg?: string): void {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return;
+    const c = this.cells[y]![x]!;
+    c.char = char;
+    if (fg) c.fg = fg;
+    if (bg) c.bg = bg;
+  }
+
+  get(x: number, y: number): Cell | null {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return null;
+    return this.cells[y]![x]!;
+  }
+
+  drawText(x: number, y: number, text: string, fg?: string, bg?: string): void {
+    for (let i = 0; i < text.length; i++) {
+      this.set(x + i, y, text[i]!, fg, bg);
+    }
+  }
+
+  // Convert each row to run-length-encoded spans of same-colored text.
+  // This minimizes the number of React Text elements needed.
+  toSpanRows(): TextSpan[][] {
+    const rows: TextSpan[][] = [];
+    for (let y = 0; y < this.height; y++) {
+      const spans: TextSpan[] = [];
+      let spanFg = '';
+      let spanBg = '';
+      let spanChars = '';
+
+      for (let x = 0; x < this.width; x++) {
+        const c = this.cells[y]![x]!;
+        if (c.fg !== spanFg || c.bg !== spanBg) {
+          if (spanChars.length > 0) {
+            spans.push({ text: spanChars, fg: spanFg, bg: spanBg });
+          }
+          spanFg = c.fg;
+          spanBg = c.bg;
+          spanChars = c.char;
+        } else {
+          spanChars += c.char;
+        }
+      }
+      if (spanChars.length > 0) {
+        spans.push({ text: spanChars, fg: spanFg, bg: spanBg });
+      }
+      rows.push(spans);
+    }
+    return rows;
+  }
+}