@vsuryav/agent-sim 0.1.0

package/README.md

@@ -0,0 +1,25 @@
+# agent sim
+
+a cute pastel idle world that grows from your agentic coding sessions.
+
+## install
+
+```bash
+npm install -g @vsuryav/agent-sim
+```
+
+## first run
+
+```bash
+agent-sim login https://degenerately-muscleless-athena.ngrok-free.dev
+agent-sim
+```
+
+the app will:
+
+- scan your local coding sessions
+- rebuild your world locally
+- pull your synced agents from the server
+- keep pushing new state while the app is open
+
+legacy `agent-wars` local data is migrated automatically to `~/.agent-sim` on first run.

package/bin/agent-sim.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const cliEntry = fileURLToPath(new URL('../src/cli.ts', import.meta.url));
+
+const child = spawn(
+  process.execPath,
+  ['--import', 'tsx', cliEntry, ...process.argv.slice(2)],
+  { stdio: 'inherit' },
+);
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 0);
+});
+
+child.on('error', (error) => {
+  console.error(error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@vsuryav/agent-sim",
+  "version": "0.1.0",
+  "description": "Local TUI and sync client for Agent Sim",
+  "type": "module",
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "bin": {
+    "agent-sim": "bin/agent-sim.js",
+    "agent-wars": "bin/agent-sim.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vsuryav/agent-wars.git"
+  },
+  "homepage": "https://github.com/vsuryav/agent-wars",
+  "bugs": {
+    "url": "https://github.com/vsuryav/agent-wars/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/main.tsx",
+    "start": "node dist/main.js",
+    "test": "vitest run src",
+    "test:watch": "vitest src"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@vsuryav/agent-sim-contracts": "^0.1.0",
+    "@vsuryav/agent-sim-core": "^0.1.0",
+    "@alcalzone/ansi-tokenize": "^0.1.3",
+    "auto-bind": "^5.0.1",
+    "better-sqlite3": "^11.0.0",
+    "bidi-js": "^1.0.3",
+    "chalk": "^5.4.0",
+    "cli-boxes": "^3.0.0",
+    "code-excerpt": "^4.0.0",
+    "emoji-regex": "^10.4.0",
+    "figures": "^6.1.0",
+    "get-east-asian-width": "^1.3.0",
+    "indent-string": "^5.0.0",
+    "lodash-es": "^4.17.21",
+    "react": "^19.0.0",
+    "react-reconciler": "^0.31.0",
+    "semver": "^7.6.0",
+    "signal-exit": "^4.1.0",
+    "stack-utils": "^2.0.6",
+    "strip-ansi": "^7.1.0",
+    "supports-hyperlinks": "^3.1.0",
+    "tsx": "^4.19.0",
+    "type-fest": "^4.30.0",
+    "usehooks-ts": "^3.1.0",
+    "wrap-ansi": "^9.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/lodash-es": "^4.17.12",
+    "@types/react": "^19.0.0",
+    "@types/react-reconciler": "^0.28.0",
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.3"
+  }
+}

package/src/app-paths.ts

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export const APP_NAME = 'agent-sim';
+export const APP_TITLE = 'Agent Sim';
+export const LEGACY_APP_NAME = 'agent-wars';
+
+export const DATA_DIR = path.join(os.homedir(), `.${APP_NAME}`);
+export const LEGACY_DATA_DIR = path.join(os.homedir(), `.${LEGACY_APP_NAME}`);
+export const DB_PATH = path.join(DATA_DIR, 'db.sqlite');
+export const CONFIG_PATH = path.join(DATA_DIR, 'config.json');
+
+function pathExists(target: string): boolean {
+  try {
+    fs.accessSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function ensureLocalDataDir(): void {
+  if (!pathExists(DATA_DIR) && pathExists(LEGACY_DATA_DIR)) {
+    fs.renameSync(LEGACY_DATA_DIR, DATA_DIR);
+  }
+
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+}

package/src/app-sync.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { closeDb } from './collector/db.js';
+
+const syncAllMock = vi.fn();
+const getAllAgentsMock = vi.fn();
+const hasRemoteConfigMock = vi.fn();
+const pushToServerMock = vi.fn();
+const pullFromServerMock = vi.fn();
+
+vi.mock('./collector/sync.js', async () => {
+  const actual = await vi.importActual<typeof import('./collector/sync.js')>('./collector/sync.js');
+  return {
+    ...actual,
+    syncAll: syncAllMock,
+    getAllAgents: getAllAgentsMock,
+  };
+});
+
+vi.mock('./collector/remote-sync.js', () => ({
+  hasRemoteConfig: hasRemoteConfigMock,
+  pushToServer: pushToServerMock,
+  pullFromServer: pullFromServerMock,
+}));
+
+describe('startPeriodicRemoteSync', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    hasRemoteConfigMock.mockReturnValue(true);
+    syncAllMock.mockReturnValue({ newAgents: 1, totalAgents: 3 });
+    getAllAgentsMock.mockReturnValue([{ id: 'agent-1' }]);
+    pushToServerMock.mockResolvedValue({ synced: 3 });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    closeDb();
+  });
+
+  it('pushes periodically while the app is running', async () => {
+    const { startPeriodicRemoteSync } = await import('./app-sync.js');
+    const onSync = vi.fn();
+    const controller = startPeriodicRemoteSync({ intervalMs: 1_000, onSync });
+
+    expect(controller).toBeTruthy();
+
+    await vi.advanceTimersByTimeAsync(1_000);
+
+    expect(syncAllMock).toHaveBeenCalledTimes(1);
+    expect(pushToServerMock).toHaveBeenCalledTimes(1);
+    expect(onSync).toHaveBeenCalledWith({
+      local: { newAgents: 1, totalAgents: 3 },
+      remotePush: { synced: 3 },
+    });
+
+    await controller!.stop();
+  });
+
+  it('flushes one final push when stopped', async () => {
+    const { startPeriodicRemoteSync } = await import('./app-sync.js');
+    const controller = startPeriodicRemoteSync({ intervalMs: 60_000 });
+
+    await controller!.stop(true);
+
+    expect(syncAllMock).toHaveBeenCalledTimes(1);
+    expect(pushToServerMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not start when remote sync is not configured', async () => {
+    hasRemoteConfigMock.mockReturnValue(false);
+    const { startPeriodicRemoteSync } = await import('./app-sync.js');
+
+    expect(startPeriodicRemoteSync()).toBeNull();
+  });
+});

package/src/app-sync.ts

@@ -0,0 +1,110 @@
+import { getAllAgents, mergeRemoteState, syncAll, type SyncResult, type UpsertResult } from './collector/sync.js';
+import { hasRemoteConfig, pullFromServer, pushToServer } from './collector/remote-sync.js';
+
+export const DEFAULT_PERIODIC_REMOTE_SYNC_MS = 60_000;
+
+export interface StartupSyncResult {
+  local: SyncResult;
+  remotePull?: {
+    remoteAgents: number;
+    merge: UpsertResult;
+    githubLogin: string;
+  };
+  remotePush?: {
+    synced: number;
+  };
+  remoteError?: string;
+}
+
+export async function runStartupSync(): Promise<StartupSyncResult> {
+  const local = syncAll();
+  const result: StartupSyncResult = { local };
+
+  if (!hasRemoteConfig()) return result;
+
+  try {
+    const remote = await pullFromServer();
+    result.remotePull = {
+      remoteAgents: remote.agents.length,
+      merge: mergeRemoteState(remote),
+      githubLogin: remote.world.github_login,
+    };
+
+    result.remotePush = await pushToServer(getAllAgents());
+  } catch (error) {
+    result.remoteError = error instanceof Error ? error.message : String(error);
+  }
+
+  return result;
+}
+
+export async function runRemotePush(): Promise<{ synced: number } | null> {
+  if (!hasRemoteConfig()) return null;
+  syncAll();
+  return pushToServer(getAllAgents());
+}
+
+export interface PeriodicRemoteSyncUpdate {
+  local: SyncResult;
+  remotePush: {
+    synced: number;
+  };
+}
+
+export interface PeriodicRemoteSyncController {
+  stop(flush?: boolean): Promise<void>;
+}
+
+export function startPeriodicRemoteSync(options: {
+  intervalMs?: number;
+  onError?: (message: string) => void;
+  onSync?: (update: PeriodicRemoteSyncUpdate) => void;
+} = {}): PeriodicRemoteSyncController | null {
+  if (!hasRemoteConfig()) return null;
+
+  const intervalMs = options.intervalMs ?? DEFAULT_PERIODIC_REMOTE_SYNC_MS;
+  let stopped = false;
+  let inFlight: Promise<void> | null = null;
+
+  const runTick = async (force = false) => {
+    if ((!force && stopped) || inFlight) return inFlight;
+
+    inFlight = (async () => {
+      try {
+        const local = syncAll();
+        const remotePush = await pushToServer(getAllAgents());
+        options.onSync?.({ local, remotePush });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options.onError?.(message);
+      } finally {
+        inFlight = null;
+      }
+    })();
+
+    return inFlight;
+  };
+
+  const timer = setInterval(() => {
+    void runTick();
+  }, intervalMs);
+  timer.unref?.();
+
+  return {
+    async stop(flush = false) {
+      if (stopped) {
+        if (flush && inFlight) await inFlight;
+        return;
+      }
+
+      clearInterval(timer);
+      stopped = true;
+
+      if (flush) {
+        await runTick(true);
+      } else if (inFlight) {
+        await inFlight;
+      }
+    },
+  };
+}

package/src/cli.ts

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { initDb, getDb, closeDb } from './collector/db.js';
+import { mergeRemoteState, syncAll } from './collector/sync.js';
+import { DEFAULT_SERVER_URL, getPreferredServerUrl, login, pullFromServer, setToken } from './collector/remote-sync.js';
+import { runRemotePush } from './app-sync.js';
+import { APP_NAME, DB_PATH, ensureLocalDataDir, LEGACY_APP_NAME } from './app-paths.js';
+import { printOnboardingHint, printStartupSyncSummary, runInteractiveSession } from './run-interactive.js';
+let dbInitialized = false;
+
+function ensureDataDir() {
+  ensureLocalDataDir();
+}
+
+function ensureDb() {
+  if (dbInitialized) return;
+  ensureDataDir();
+  initDb(DB_PATH);
+  dbInitialized = true;
+}
+
+function printStatus() {
+  const db = getDb();
+  const agentCount = (db.prepare('SELECT COUNT(*) as c FROM agents').get() as any).c;
+  const clanCount = (db.prepare('SELECT COUNT(*) as c FROM clans').get() as any).c;
+  const phase = (db.prepare("SELECT value FROM world WHERE key = 'phase'").get() as any)?.value ?? 'unknown';
+
+  console.log(`\n  ${APP_NAME} status`);
+  console.log(`  ─────────────────`);
+  console.log(`  Phase:    ${phase}`);
+  console.log(`  Agents:   ${agentCount}`);
+  console.log(`  Clans:    ${clanCount}`);
+
+  const clans = db.prepare('SELECT * FROM clans ORDER BY name').all() as any[];
+  for (const clan of clans) {
+    const members = db.prepare(
+      'SELECT name, maturity, tool, total_tokens FROM agents WHERE clan = ? ORDER BY created_at'
+    ).all(clan.name) as any[];
+    console.log(`\n  [${clan.name}] (${members.length} agents)`);
+    for (const m of members) {
+      const tokens = m.total_tokens >= 1_000_000
+        ? `${(m.total_tokens / 1_000_000).toFixed(1)}M`
+        : m.total_tokens >= 1_000
+          ? `${(m.total_tokens / 1_000).toFixed(0)}K`
+          : `${m.total_tokens}`;
+      console.log(`    ${m.name} — ${m.maturity} · ${tokens} tokens`);
+    }
+  }
+  console.log('');
+}
+
+function printHelp() {
+  const serverUrl = getPreferredServerUrl();
+
+  console.log(`\n  ${APP_NAME}`);
+  console.log('  ──────────');
+  console.log('  whimsical local TUI for your agentic coding life\n');
+  console.log('  Commands:');
+  console.log(`    ${APP_NAME}                 Start the game`);
+  console.log(`    ${APP_NAME} login [url]     Login for cross-machine sync (default: ${DEFAULT_SERVER_URL})`);
+  console.log(`    ${APP_NAME} sync            Scan local sessions, pull remote agents, push local agents`);
+  console.log(`    ${APP_NAME} pull            Pull remote agents only`);
+  console.log(`    ${APP_NAME} push            Push local agents only`);
+  console.log(`    ${APP_NAME} status          Print local world summary`);
+  console.log(`    ${APP_NAME} help            Show this help\n`);
+  console.log('  First run:');
+  console.log(`    ${APP_NAME} login ${serverUrl}`);
+  console.log(`    ${APP_NAME}\n`);
+  console.log(`  Legacy alias: ${LEGACY_APP_NAME}\n`);
+}
+
+const command = process.argv[2];
+
+async function main() {
+  try {
+    if (command === 'help' || command === '--help' || command === '-h') {
+      printHelp();
+    } else if (command === 'login') {
+      const serverUrl = process.argv[3] ?? DEFAULT_SERVER_URL;
+      await login(serverUrl);
+    } else if (command === 'set-token') {
+      const token = process.argv[3];
+      if (!token) { console.error(`Usage: ${APP_NAME} set-token <token>`); process.exit(1); }
+      setToken(token);
+    } else if (command === 'pull') {
+      ensureDb();
+      const remote = await pullFromServer();
+      const merge = mergeRemoteState(remote);
+      console.log(`  Pulled ${remote.agents.length} agent(s) for ${remote.world.github_login}.`);
+      console.log(`  Added ${merge.inserted} new local agent(s), updated ${merge.updated}.`);
+    } else if (command === 'push') {
+      ensureDb();
+      const pushResult = await runRemotePush();
+      if (!pushResult) {
+        throw new Error(`Not logged in. Run: ${APP_NAME} login <server-url>`);
+      }
+      console.log(`  Pushed ${pushResult.synced} agents to server.`);
+    } else {
+      if (command === 'sync') {
+        ensureDb();
+        const { runStartupSync } = await import('./app-sync.js');
+        const result = await runStartupSync();
+        printStartupSyncSummary(result);
+      } else if (command === 'status') {
+        ensureDb();
+        const result = syncAll();
+        if (result.newAgents > 0) {
+          console.log(`  Synced ${result.newAgents} new agent(s). Total: ${result.totalAgents}`);
+        }
+      }
+
+      if (command === 'status' || command === 'sync') {
+        printStatus();
+      }
+
+      if (!command) {
+        ensureDb();
+        await runInteractiveSession();
+      } else if (command) {
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exitCode = 1;
+      }
+    }
+  } finally {
+    closeDb();
+  }
+}
+
+main();

package/src/collector/claude-code.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { scanClaudeCode } from './claude-code.js';
+import { initDb, getDb, closeDb } from './db.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('Claude Code collector', () => {
+  const testDir = path.join(os.tmpdir(), `agent-sim-cc-test-${Date.now()}`);
+  const testDbPath = path.join(testDir, 'db.sqlite');
+  const mockClaudeDir = path.join(testDir, '.claude');
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+    initDb(testDbPath);
+    fs.mkdirSync(path.join(mockClaudeDir, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(mockClaudeDir, 'projects', '-test-project'), { recursive: true });
+  });
+
+  afterEach(() => {
+    closeDb();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('discovers sessions from session files', () => {
+    fs.writeFileSync(
+      path.join(mockClaudeDir, 'sessions', '1234.json'),
+      JSON.stringify({
+        pid: 1234,
+        sessionId: 'test-uuid-1',
+        cwd: '/test/project',
+        startedAt: 1700000000000,
+        kind: 'interactive',
+        entrypoint: 'cli',
+      })
+    );
+
+    const convLines = [
+      JSON.stringify({
+        type: 'summary',
+        sessionId: 'test-uuid-1',
+        parentUuid: null,
+      }),
+      JSON.stringify({
+        parentUuid: 'root',
+        type: 'message',
+        message: {
+          role: 'assistant',
+          model: 'claude-opus-4-6',
+          content: [
+            { type: 'text', text: 'hello' },
+            { type: 'tool_use', name: 'Bash', id: 't1', input: {} },
+          ],
+          usage: {
+            input_tokens: 100,
+            output_tokens: 200,
+            cache_read_input_tokens: 1000,
+            cache_creation_input_tokens: 500,
+          },
+        },
+        uuid: 'msg-1',
+        timestamp: 1700000001000,
+        sessionId: 'test-uuid-1',
+      }),
+    ];
+    fs.writeFileSync(
+      path.join(mockClaudeDir, 'projects', '-test-project', 'test-uuid-1.jsonl'),
+      convLines.join('\n')
+    );
+
+    const result = scanClaudeCode(mockClaudeDir);
+
+    expect(result.length).toBe(1);
+    expect(result[0].id).toBe('test-uuid-1');
+    expect(result[0].tool).toBe('claude-code');
+    expect(result[0].model).toBe('claude-opus-4-6');
+    expect(result[0].input_tokens).toBe(100);
+    expect(result[0].output_tokens).toBe(200);
+    expect(result[0].cache_tokens).toBe(1500);
+    expect(result[0].trait_builder).toBeGreaterThan(0);
+  });
+
+  it('skips sessions already in the database', () => {
+    const db = getDb();
+    db.prepare(`INSERT INTO agents (id, tool, project, clan, created_at)
+      VALUES (?, ?, ?, ?, ?)`).run('test-uuid-1', 'claude-code', '/test/project', 'project', Date.now());
+
+    fs.writeFileSync(
+      path.join(mockClaudeDir, 'sessions', '1234.json'),
+      JSON.stringify({
+        pid: 1234,
+        sessionId: 'test-uuid-1',
+        cwd: '/test/project',
+        startedAt: 1700000000000,
+        kind: 'interactive',
+      })
+    );
+
+    const result = scanClaudeCode(mockClaudeDir);
+    expect(result.length).toBe(0);
+  });
+});