@vsuryav/agent-sim 0.1.0

package/src/game/launch.ts

@@ -0,0 +1,36 @@
+// Launch the TUI game from the CLI. Loads data from DB and renders.
+import React from 'react';
+import { APP_NAME } from '../app-paths.js';
+import { getDb } from '../collector/db.js';
+import { createRoot } from '../engine/ink/root.js';
+import { GameApp } from './App.js';
+
+export async function launchGame(): Promise<void> {
+  const db = getDb();
+  const agents = db.prepare('SELECT * FROM agents ORDER BY created_at').all() as any[];
+  const clans = db.prepare('SELECT * FROM clans ORDER BY name').all() as any[];
+  const phase = (db.prepare("SELECT value FROM world WHERE key = 'phase'").get() as any)?.value ?? 'space';
+  const day = parseInt((db.prepare("SELECT value FROM world WHERE key = 'day'").get() as any)?.value ?? '0', 10);
+  const seed = parseInt((db.prepare("SELECT value FROM world WHERE key = 'seed'").get() as any)?.value ?? '42', 10);
+
+  if (agents.length === 0) {
+    console.log('\n  No agents found yet. Start an agentic coding session first.');
+    console.log(`  Run \`${APP_NAME} sync\` to manually scan for sessions.\n`);
+    return;
+  }
+
+  const root = await createRoot({ exitOnCtrlC: true });
+  let quitting = false;
+
+  const quit = () => {
+    if (quitting) return;
+    quitting = true;
+    root.unmount();
+  };
+
+  root.render(
+    React.createElement(GameApp, { agents, clans, phase, day, seed, onQuit: quit })
+  );
+
+  await root.waitUntilExit();
+}

package/src/game/ship/ShipView.tsx

@@ -0,0 +1,145 @@
+// Ship interior renderer for Phase 1-2.
+// Draws ship tiles, stars, agents, speech bubbles using Canvas -> Text spans.
+
+import React, { useMemo, useRef } from 'react';
+import { useAnimationFrame } from '../../engine/ink/hooks/use-animation-frame.js';
+import Box from '../../engine/ink/components/Box.js';
+import Text from '../../engine/ink/components/Text.js';
+import { Canvas, type TextSpan } from '../canvas.js';
+import { getTileVisual, type ShipLayout } from './ship-map.js';
+import { lerpAgent, type AgentSim } from '../agents/behavior.js';
+import { stateSpeech } from '../agents/speech.js';
+import type { Color } from '../../engine/ink/styles.js';
+
+interface Props {
+  ship: ShipLayout;
+  agents: AgentSim[];
+  viewWidth: number;
+  viewHeight: number;
+  seed: number;
+  selectedAgentId: string | null;
+  paused: boolean;
+}
+
+interface Star { x: number; y: number; char: string; brightness: number; }
+
+function generateStars(w: number, h: number, seed: number): Star[] {
+  const stars: Star[] = [];
+  let s = seed;
+  const rand = () => { s = (s * 1103515245 + 12345) & 0x7fffffff; return s / 0x7fffffff; };
+  const chars = ['.', '*', '+', '`'];
+  for (let y = 0; y < h * 2; y++) {
+    for (let x = 0; x < w * 2; x++) {
+      if (rand() < 0.015) {
+        stars.push({ x, y, char: chars[Math.floor(rand() * chars.length)]!, brightness: 0.3 + rand() * 0.7 });
+      }
+    }
+  }
+  return stars;
+}
+
+// Memoized row component to prevent unnecessary re-renders
+function CanvasRow({ spans }: { spans: TextSpan[] }): React.ReactNode {
+  return (
+    <Box>
+      {spans.map((span, i) => (
+        <Text key={i} color={span.fg as Color} backgroundColor={span.bg as Color}>{span.text}</Text>
+      ))}
+    </Box>
+  );
+}
+
+export function ShipView({ ship, agents, viewWidth, viewHeight, seed, selectedAgentId, paused }: Props): React.ReactNode {
+  const [animRef, time] = useAnimationFrame(paused ? null : 100); // 10fps for stability
+  const frame = Math.floor(time / 100);
+  const lastSpeechTime = useRef(0);
+
+  // Reuse canvas
+  const canvasRef = useRef<Canvas | null>(null);
+  if (!canvasRef.current || canvasRef.current.width !== viewWidth || canvasRef.current.height !== viewHeight) {
+    canvasRef.current = new Canvas(viewWidth, viewHeight);
+  }
+  const canvas = canvasRef.current;
+
+  const stars = useMemo(() => generateStars(ship.width, ship.height, seed), [ship.width, ship.height, seed]);
+
+  // Camera centered on ship
+  const selected = agents.find(a => a.id === selectedAgentId);
+  const camX = Math.round((selected ? selected.renderX : ship.width / 2) - viewWidth / 2);
+  const camY = Math.round((selected ? selected.renderY : ship.height / 2) - viewHeight / 2);
+
+  // Lerp agents
+  for (const agent of agents) { lerpAgent(agent, 100); }
+
+  // Speech at ~3Hz
+  if (time - lastSpeechTime.current > 300) {
+    lastSpeechTime.current = time;
+    for (const agent of agents) {
+      if (agent.speechTimer > 0) agent.speechTimer--;
+      if (agent.speechTimer <= 0) agent.speech = null;
+      if (!agent.speech) {
+        const speech = stateSpeech(agent.state);
+        if (speech) { agent.speech = speech; agent.speechTimer = 10; }
+      }
+    }
+  }
+
+  // Clear
+  canvas.clear('#222233', '#0a0a14');
+
+  // Stars
+  for (const star of stars) {
+    const sx = star.x - camX;
+    const sy = star.y - camY;
+    if (sx >= 0 && sx < viewWidth && sy >= 0 && sy < viewHeight) {
+      const twinkle = Math.sin(frame * 0.15 + star.x * 7 + star.y * 13) * 0.3 + 0.7;
+      const b = Math.floor(star.brightness * twinkle * 140 + 40);
+      const bh = Math.max(0, Math.min(255, b)).toString(16).padStart(2, '0');
+      canvas.set(sx, sy, star.char, `#${bh}${bh}ff`);
+    }
+  }
+
+  // Ship tiles
+  for (let wy = 0; wy < ship.height; wy++) {
+    for (let wx = 0; wx < ship.width; wx++) {
+      const sx = wx - camX;
+      const sy = wy - camY;
+      if (sx < 0 || sx >= viewWidth || sy < 0 || sy >= viewHeight) continue;
+      const tile = ship.tiles[wy]?.[wx];
+      if (!tile || tile === 'void') continue;
+      const v = getTileVisual(tile);
+      canvas.set(sx, sy, v.char, v.fg, v.bg);
+    }
+  }
+
+  // Agents
+  for (const agent of agents) {
+    const sx = Math.round(agent.renderX) - camX;
+    const sy = Math.round(agent.renderY) - camY;
+    if (sx < 0 || sx >= viewWidth || sy < 0 || sy >= viewHeight) continue;
+
+    const isSel = agent.id === selectedAgentId;
+    canvas.set(sx, sy, agent.state === 'sleeping' ? 'z' : agent.sprite,
+      isSel ? '#ffffff' : agent.color, isSel ? '#444444' : '#1a2a1a');
+
+    // Speech
+    if (agent.speech && sy > 0) {
+      const text = agent.speech.slice(0, Math.min(14, viewWidth - sx));
+      canvas.drawText(Math.max(0, sx - 1), sy - 1, text, '#eeeecc', '#333322');
+    }
+
+    // Name below selected
+    if (isSel && sy < viewHeight - 1) {
+      const tag = agent.name.slice(0, 12);
+      canvas.drawText(Math.max(0, sx - Math.floor(tag.length / 2)), sy + 1, tag, '#cccccc', '#222222');
+    }
+  }
+
+  const spanRows = canvas.toSpanRows();
+
+  return (
+    <Box ref={animRef} flexDirection="column" flexGrow={1}>
+      {spanRows.map((spans, y) => <CanvasRow key={y} spans={spans} />)}
+    </Box>
+  );
+}

package/src/game/ship/ship-map.ts

@@ -0,0 +1,172 @@
+// Ship interior layout for Phase 1-2 (space, before planetfall).
+// The ship grows as crew count increases. Tile map is a simple 2D grid.
+
+export type TileType =
+  | 'void'    // empty space (stars)
+  | 'hull'    // outer ship wall
+  | 'wall'    // inner wall
+  | 'floor'   // walkable floor
+  | 'window'  // transparent hull (see stars)
+  | 'door'    // walkable passage between rooms
+  | 'console' // bridge control panel
+  | 'bed'     // crew quarters
+  | 'plant'   // garden/plant
+  | 'crate'   // cargo storage
+  | 'engine'  // engine component
+  | 'table';  // mess hall table
+
+export interface TileVisual {
+  char: string;
+  fg: string;
+  bg: string;
+}
+
+// Visual mapping for each tile type
+const TILE_VISUALS: Record<TileType, TileVisual> = {
+  void:    { char: ' ', fg: '#222233', bg: '#0a0a14' },
+  hull:    { char: '█', fg: '#445566', bg: '#334455' },
+  wall:    { char: '▓', fg: '#556677', bg: '#3a4a5a' },
+  floor:   { char: '·', fg: '#3a4a3a', bg: '#1a2a1a' },
+  window:  { char: '░', fg: '#4488cc', bg: '#223355' },
+  door:    { char: '▒', fg: '#887744', bg: '#2a2a1a' },
+  console: { char: '◈', fg: '#44ddcc', bg: '#1a2a2a' },
+  bed:     { char: '▬', fg: '#aa7744', bg: '#1a2a1a' },
+  plant:   { char: '♣', fg: '#44cc44', bg: '#1a2a1a' },
+  crate:   { char: '▣', fg: '#aa8855', bg: '#1a2a1a' },
+  engine:  { char: '⚙', fg: '#dd8844', bg: '#1a1a1a' },
+  table:   { char: '▫', fg: '#886644', bg: '#1a2a1a' },
+};
+
+export function getTileVisual(type: TileType): TileVisual {
+  return TILE_VISUALS[type];
+}
+
+export function isWalkable(type: TileType): boolean {
+  return type === 'floor' || type === 'door';
+}
+
+export interface Room {
+  name: string;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+export interface ShipLayout {
+  width: number;
+  height: number;
+  tiles: TileType[][];
+  rooms: Room[];
+  spawnPoints: Array<{ x: number; y: number }>;
+}
+
+// Ship layout encoded as string map.
+// Legend: ~ void, # hull, | wall, . floor, = window, + door,
+//         C console, B bed, P plant, X crate, E engine, T table
+const SHIP_SMALL = [
+  '~~~~~~~~~~#####~~~~~~~~~~',
+  '~~~~~~~~##=...=##~~~~~~~~',
+  '~~~~~~~#...CCC...#~~~~~~~',
+  '~~~~~~~#...CCC...#~~~~~~~',
+  '~~~~~~~#.........#~~~~~~~',
+  '~~~~~~~=.........=~~~~~~~',
+  '~~~~~###+###.###+###~~~~~',
+  '~~~~~#.....#.#.....#~~~~~',
+  '~~~~~#.BB..+.+..XX.#~~~~~',
+  '~~~~~#.BB..#.#..XX.#~~~~~',
+  '~~~~~#.....#.#.....#~~~~~',
+  '~~~~~###+###.###+###~~~~~',
+  '~~~~~#.....#.#.....#~~~~~',
+  '~~~~~#.TT..+.+..EE.#~~~~~',
+  '~~~~~#.TT..#.#..EE.#~~~~~',
+  '~~~~~#.PP..#.#.....#~~~~~',
+  '~~~~~###+###.###+###~~~~~',
+  '~~~~~~~#.........#~~~~~~~',
+  '~~~~~~~#.........#~~~~~~~',
+  '~~~~~~~=.........=~~~~~~~',
+  '~~~~~~~###=#=#=###~~~~~~~',
+  '~~~~~~~~~~#####~~~~~~~~~~',
+];
+
+// Bigger ship unlocked at 6+ agents - adds more rooms
+const SHIP_MEDIUM = [
+  '~~~~~~~~~~~~######~~~~~~~~~~~~',
+  '~~~~~~~~~###=....=###~~~~~~~~~',
+  '~~~~~~~~#....CCCC....#~~~~~~~~',
+  '~~~~~~~~#....CCCC....#~~~~~~~~',
+  '~~~~~~~~#............#~~~~~~~~',
+  '~~~~~~~~=............=~~~~~~~~',
+  '~~~~~~###+####..####+###~~~~~~',
+  '~~~~~~#......#..#......#~~~~~~',
+  '~~~~~~#.BBB..+..+..XXX.#~~~~~~',
+  '~~~~~~#.BBB..#..#..XXX.#~~~~~~',
+  '~~~~~~#......#..#......#~~~~~~',
+  '~~~~##+####+##..##+####+##~~~~',
+  '~~~~#......#......#......#~~~~',
+  '~~~~#.BBB..+......+..PP..#~~~~',
+  '~~~~#.BBB..#......#..PP..#~~~~',
+  '~~~~#......#......#......#~~~~',
+  '~~~~##+####+##..##+####+##~~~~',
+  '~~~~~~#......#..#......#~~~~~~',
+  '~~~~~~#.TTT..+..+..EEE.#~~~~~~',
+  '~~~~~~#.TTT..#..#..EEE.#~~~~~~',
+  '~~~~~~#.PP...#..#..EEE.#~~~~~~',
+  '~~~~~~###+####..####+###~~~~~~',
+  '~~~~~~~~#............#~~~~~~~~',
+  '~~~~~~~~#............#~~~~~~~~',
+  '~~~~~~~~=............=~~~~~~~~',
+  '~~~~~~~~####=##=####~~~~~~~~~',
+  '~~~~~~~~~~~~######~~~~~~~~~~~~',
+];
+
+const CHAR_TO_TILE: Record<string, TileType> = {
+  '~': 'void',
+  '#': 'hull',
+  '|': 'wall',
+  '.': 'floor',
+  '=': 'window',
+  '+': 'door',
+  'C': 'console',
+  'B': 'bed',
+  'P': 'plant',
+  'X': 'crate',
+  'E': 'engine',
+  'T': 'table',
+};
+
+function parseShipLayout(lines: string[]): ShipLayout {
+  const height = lines.length;
+  const width = Math.max(...lines.map(l => l.length));
+  const tiles: TileType[][] = [];
+  const spawnPoints: Array<{ x: number; y: number }> = [];
+
+  for (let y = 0; y < height; y++) {
+    const row: TileType[] = [];
+    const line = lines[y]!;
+    for (let x = 0; x < width; x++) {
+      const ch = x < line.length ? line[x]! : '~';
+      const tile = CHAR_TO_TILE[ch] ?? 'void';
+      row.push(tile);
+      // Collect floor tiles as potential spawn points
+      if (tile === 'floor') {
+        spawnPoints.push({ x, y });
+      }
+    }
+    tiles.push(row);
+  }
+
+  // Detect rooms (named areas)
+  const rooms: Room[] = [];
+  // Bridge is always the top area
+  rooms.push({ name: 'Bridge', x: Math.floor(width / 2) - 3, y: 2, w: 6, h: 3 });
+
+  return { width, height, tiles, rooms, spawnPoints };
+}
+
+export function generateShip(agentCount: number): ShipLayout {
+  if (agentCount >= 6) {
+    return parseShipLayout(SHIP_MEDIUM);
+  }
+  return parseShipLayout(SHIP_SMALL);
+}

package/src/game/ui/AgentBio.tsx

@@ -0,0 +1,72 @@
+// Full agent profile view with personality trait bars and origin info.
+
+import React from 'react';
+import Box from '../../engine/ink/components/Box.js';
+import Text from '../../engine/ink/components/Text.js';
+import type { AgentSim } from '../agents/behavior.js';
+
+interface Props {
+  agent: AgentSim;
+  onClose: () => void;
+}
+
+function TraitBar({ label, value, color }: { label: string; value: number; color: string }): React.ReactNode {
+  const barWidth = 20;
+  const filled = Math.round(value * barWidth);
+  const empty = barWidth - filled;
+  return (
+    <Box>
+      <Text color="#888888">  {label.padEnd(10)}</Text>
+      <Text color={color}>{'█'.repeat(filled)}</Text>
+      <Text color="#333333">{'░'.repeat(empty)}</Text>
+      <Text color="#666666">{' '}{(value * 100).toFixed(0)}%</Text>
+    </Box>
+  );
+}
+
+export function AgentBio({ agent, onClose }: Props): React.ReactNode {
+  const t = agent.traits;
+
+  return (
+    <Box flexDirection="column" paddingX={2} paddingY={1}>
+      <Box>
+        <Text color={agent.color} bold>
+          {'  '}{agent.sprite} {agent.name}
+        </Text>
+        <Text color="#666666">
+          {'  '}{agent.maturity} · {agent.clan}
+        </Text>
+      </Box>
+
+      <Text color="#444444">  {'─'.repeat(40)}</Text>
+
+      <Box flexDirection="column" marginTop={1}>
+        <Text color="#888888">  Personality</Text>
+        <TraitBar label="Builder" value={t.builder} color="#ff8844" />
+        <TraitBar label="Creator" value={t.creator} color="#44cc88" />
+        <TraitBar label="Explorer" value={t.explorer} color="#4488ff" />
+        <TraitBar label="Leader" value={t.leader} color="#ff44aa" />
+        <TraitBar label="Thinker" value={t.thinker} color="#aa88ff" />
+        <TraitBar label="Scholar" value={t.scholar} color="#ffcc44" />
+      </Box>
+
+      <Box flexDirection="column" marginTop={1}>
+        <Text color="#888888">  Status</Text>
+        <Text color="#666666">  Energy    {energyBar(agent.energy)}</Text>
+        <Text color="#666666">  State     {agent.state}</Text>
+        <Text color="#666666">  Position  ({agent.x}, {agent.y})</Text>
+      </Box>
+
+      <Box marginTop={1}>
+        <Text color="#555566">  Press [b] or [esc] to return</Text>
+      </Box>
+    </Box>
+  );
+}
+
+function energyBar(energy: number): string {
+  const width = 20;
+  const filled = Math.round((energy / 100) * width);
+  const color = energy > 60 ? '█' : energy > 30 ? '▓' : '░';
+  return color.repeat(filled) + '·'.repeat(width - filled) + ` ${Math.round(energy)}%`;
+}

package/src/game/ui/HUD.tsx

@@ -0,0 +1,63 @@
+// Top status bar showing game state, phase, selected agent info.
+
+import React from 'react';
+import Box from '../../engine/ink/components/Box.js';
+import Text from '../../engine/ink/components/Text.js';
+import type { AgentSim } from '../agents/behavior.js';
+
+interface Props {
+  phase: string;
+  agentCount: number;
+  clanCount: number;
+  day: number;
+  selectedAgent: AgentSim | null;
+  paused: boolean;
+}
+
+const PHASE_LABELS: Record<string, string> = {
+  space: '🚀 SPACE',
+  ship: '🛸 SHIP',
+  planet: '🌍 PLANETFALL',
+  settlement: '🏘 SETTLEMENT',
+  civilization: '🏛 CIVILIZATION',
+};
+
+const STATE_LABELS: Record<string, string> = {
+  idle: '💭 thinking',
+  walking: '🚶 walking',
+  sleeping: '😴 sleeping',
+  chatting: '💬 chatting',
+  working: '⚒ working',
+  exploring: '🔍 exploring',
+};
+
+export function HUD({ phase, agentCount, clanCount, day, selectedAgent, paused }: Props): React.ReactNode {
+  return (
+    <Box flexDirection="row" width="100%" height={1}>
+      <Box flexGrow={1}>
+        <Text color="#888888" backgroundColor="#1a1a2a">
+          {' '}{PHASE_LABELS[phase] ?? phase}
+          {' · '}
+          {agentCount} agents
+          {' · '}
+          {clanCount} clans
+          {' · '}
+          Day {day}
+          {paused ? ' · ⏸ PAUSED' : ''}
+          {'  '}
+        </Text>
+      </Box>
+      {selectedAgent && (
+        <Box>
+          <Text color={selectedAgent.color} backgroundColor="#1a1a2a">
+            {' '}{selectedAgent.name}{' '}
+          </Text>
+          <Text color="#666666" backgroundColor="#1a1a2a">
+            {selectedAgent.maturity} · {STATE_LABELS[selectedAgent.state] ?? selectedAgent.state}
+            {'  '}
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/game/ui/StatusBar.tsx

@@ -0,0 +1,49 @@
+// Bottom keybinding guide bar.
+
+import React from 'react';
+import Box from '../../engine/ink/components/Box.js';
+import Text from '../../engine/ink/components/Text.js';
+import { APP_NAME } from '../../app-paths.js';
+
+interface Props {
+  view: string;
+}
+
+export function StatusBar({ view }: Props): React.ReactNode {
+  return (
+    <Box flexDirection="row" width="100%" height={1}>
+      <Text color="#555566" backgroundColor="#111122">
+        {' [tab]'}
+      </Text>
+      <Text color="#888899" backgroundColor="#111122">
+        {' next agent '}
+      </Text>
+      <Text color="#555566" backgroundColor="#111122">
+        {' [space]'}
+      </Text>
+      <Text color="#888899" backgroundColor="#111122">
+        {' pause '}
+      </Text>
+      <Text color="#555566" backgroundColor="#111122">
+        {' [b]'}
+      </Text>
+      <Text color="#888899" backgroundColor="#111122">
+        {' bio '}
+      </Text>
+      <Text color="#555566" backgroundColor="#111122">
+        {' [q]'}
+      </Text>
+      <Text color="#888899" backgroundColor="#111122">
+        {' quit '}
+      </Text>
+      <Box flexGrow={1}>
+        <Text color="#333344" backgroundColor="#111122">
+          {''}
+        </Text>
+      </Box>
+      <Text color="#444455" backgroundColor="#111122">
+        {` ${APP_NAME} v0.1 `}
+      </Text>
+    </Box>
+  );
+}

package/src/game/useKeyboard.ts

@@ -0,0 +1,62 @@
+// Lightweight keyboard input hook that bypasses the engine's useInput.
+// Reads raw stdin directly with minimal processing.
+
+import { useEffect, useRef } from 'react';
+
+export interface KeyEvent {
+  raw: string;
+  key: string;
+  ctrl: boolean;
+  tab: boolean;
+  escape: boolean;
+  space: boolean;
+}
+
+type KeyHandler = (event: KeyEvent) => void;
+
+export function useKeyboard(handler: KeyHandler): void {
+  const handlerRef = useRef(handler);
+  handlerRef.current = handler;
+
+  useEffect(() => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+      stdin.resume();
+    }
+
+    const onData = (data: Buffer) => {
+      const str = data.toString('utf-8');
+      const event: KeyEvent = {
+        raw: str,
+        key: str,
+        ctrl: false,
+        tab: str === '\t',
+        escape: str === '\x1b',
+        space: str === ' ',
+      };
+
+      // Detect ctrl+key (0x01-0x1a)
+      if (str.length === 1) {
+        const code = str.charCodeAt(0);
+        if (code >= 1 && code <= 26) {
+          event.ctrl = true;
+          event.key = String.fromCharCode(code + 96); // ctrl+a = 1, etc.
+        }
+      }
+
+      handlerRef.current(event);
+    };
+
+    stdin.on('data', onData);
+
+    return () => {
+      stdin.removeListener('data', onData);
+      if (stdin.isTTY && !wasRaw) {
+        stdin.setRawMode(false);
+      }
+    };
+  }, []);
+}

package/src/main.tsx

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// Dev entry point: perform startup sync, then launch the TUI game.
+
+import { DB_PATH, ensureLocalDataDir } from './app-paths.js';
+import { initDb, closeDb } from './collector/db.js';
+import { runInteractiveSession } from './run-interactive.js';
+
+async function main() {
+  ensureLocalDataDir();
+  initDb(DB_PATH);
+
+  try {
+    await runInteractiveSession();
+  } finally {
+    closeDb();
+  }
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});