@vsuryav/agent-sim 0.1.0

package/src/collector/personality.ts

@@ -0,0 +1,46 @@
+export interface Traits {
+  builder: number;
+  creator: number;
+  explorer: number;
+  leader: number;
+  thinker: number;
+  scholar: number;
+}
+
+export function extractTraits(
+  toolCounts: Record<string, number>,
+  contentTypeCounts: Record<string, number>,
+  messageCount: number,
+  durationMs: number,
+): Traits {
+  const totalToolUse = Object.values(toolCounts).reduce((a, b) => a + b, 0) || 1;
+  const totalContent = Object.values(contentTypeCounts).reduce((a, b) => a + b, 0) || 1;
+
+  // Builder: Bash, shell commands
+  const bashCount = (toolCounts['Bash'] ?? 0) + (toolCounts['bash'] ?? 0);
+  const builder = Math.min(1, bashCount / totalToolUse * 2);
+
+  // Creator: Write, Edit, NotebookEdit
+  const writeCount = (toolCounts['Write'] ?? 0) + (toolCounts['Edit'] ?? 0) + (toolCounts['NotebookEdit'] ?? 0);
+  const creator = Math.min(1, writeCount / totalToolUse * 2.5);
+
+  // Explorer: Read, Grep, Glob, LS
+  const readCount = (toolCounts['Read'] ?? 0) + (toolCounts['Grep'] ?? 0)
+    + (toolCounts['Glob'] ?? 0) + (toolCounts['LS'] ?? 0);
+  const explorer = Math.min(1, readCount / totalToolUse * 2);
+
+  // Leader: Agent, subagent delegation
+  const agentCount = toolCounts['Agent'] ?? 0;
+  const leader = Math.min(1, agentCount / Math.max(1, totalToolUse) * 8);
+
+  // Thinker: thinking blocks relative to total content
+  const thinkingCount = contentTypeCounts['thinking'] ?? 0;
+  const thinker = Math.min(1, thinkingCount / totalContent * 3);
+
+  // Scholar: WebSearch, WebFetch
+  const searchCount = (toolCounts['WebSearch'] ?? 0) + (toolCounts['WebFetch'] ?? 0)
+    + (toolCounts['web_search_end'] ?? 0);
+  const scholar = Math.min(1, searchCount / Math.max(1, totalToolUse) * 5);
+
+  return { builder, creator, explorer, leader, thinker, scholar };
+}

package/src/collector/remote-sync.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { buildPushPayload, getDeviceId } from './remote-sync.js';
+
+describe('remote-sync', () => {
+  it('getDeviceId returns consistent hash', () => {
+    const id1 = getDeviceId();
+    const id2 = getDeviceId();
+    expect(id1).toBe(id2);
+    expect(typeof id1).toBe('string');
+    expect(id1.length).toBeGreaterThan(10);
+  });
+
+  it('buildPushPayload formats agents correctly', () => {
+    const agents = [
+      {
+        id: 'test-1', tool: 'claude-code', model: 'opus', project: '/p', clan: 'p',
+        created_at: 1000, total_tokens: 500, input_tokens: 100, output_tokens: 400,
+        cache_tokens: 0, reasoning_tokens: 0, duration_ms: 0, message_count: 5,
+        trait_builder: 0.5, trait_creator: 0.3, trait_explorer: 0.2,
+        trait_leader: 0.0, trait_thinker: 0.1, trait_scholar: 0.0,
+        name: 'Bold Spark', maturity: 'spark',
+      },
+    ];
+
+    const payload = buildPushPayload(agents);
+    expect(payload.device_id).toBeTruthy();
+    expect(payload.hostname).toBeTruthy();
+    expect(payload.agents).toHaveLength(1);
+    expect(payload.agents[0]!.id).toBe('test-1');
+  });
+});

package/src/collector/remote-sync.ts

@@ -0,0 +1,171 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {
+  authLoginStartResponseSchema,
+  authSessionResponseSchema,
+  pullResponseSchema,
+  type CollectedAgent,
+  type PullResponse,
+} from '@vsuryav/agent-sim-contracts';
+import { APP_NAME, CONFIG_PATH, ensureLocalDataDir } from '../app-paths.js';
+
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+export const DEFAULT_SERVER_URL = process.env['AGENT_SIM_SERVER_URL']
+  ?? process.env['AGENT_WARS_SERVER_URL']
+  ?? 'http://localhost:3456';
+
+interface Config {
+  serverUrl?: string;
+  token?: string;
+}
+
+export function loadConfig(): Config {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8')) as Config;
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(config: Config): void {
+  ensureLocalDataDir();
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function hasRemoteConfig(): boolean {
+  const config = loadConfig();
+  return !!config.serverUrl && !!config.token;
+}
+
+export function getDeviceId(): string {
+  const raw = `${os.hostname()}-${os.userInfo().username}-${os.platform()}-${os.arch()}`;
+  return createHash('sha256').update(raw).digest('hex').slice(0, 32);
+}
+
+export function buildPushPayload(agents: CollectedAgent[]): { device_id: string; hostname: string; agents: CollectedAgent[] } {
+  return {
+    device_id: getDeviceId(),
+    hostname: os.hostname(),
+    agents,
+  };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function pollForLoginSession(
+  serverUrl: string,
+  sessionId: string,
+  pollIntervalMs: number,
+): Promise<{ userId: number; githubLogin: string; token: string }> {
+  const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+
+  while (Date.now() < deadline) {
+    const res = await fetch(`${serverUrl}/auth/session/${sessionId}`);
+    if (res.status === 202) {
+      await sleep(pollIntervalMs);
+      continue;
+    }
+
+    const body = await res.json() as unknown;
+    if (!res.ok) {
+      const error = body as { error?: string };
+      throw new Error(`Login failed: ${error.error ?? res.statusText}`);
+    }
+
+    const session = authSessionResponseSchema.parse(body);
+    if (session.status === 'complete') {
+      return session;
+    }
+
+    await sleep(pollIntervalMs);
+  }
+
+  throw new Error(`Login timed out. Re-run the ${APP_NAME} login command and finish GitHub auth within 5 minutes.`);
+}
+
+export async function login(serverUrl: string): Promise<void> {
+  const config = loadConfig();
+  config.serverUrl = serverUrl;
+  saveConfig(config);
+
+  const res = await fetch(`${serverUrl}/auth/login`);
+  const body = await res.json() as unknown;
+  if (!res.ok) {
+    const error = body as { error?: string };
+    throw new Error(`Login failed: ${error.error ?? res.statusText}`);
+  }
+  const { url, session_id, poll_interval_ms } = authLoginStartResponseSchema.parse(body);
+
+  console.log(`\n  Open this URL to login with GitHub:\n`);
+  console.log(`  ${url}\n`);
+  console.log('  Waiting for GitHub authorization to complete...\n');
+
+  const session = await pollForLoginSession(serverUrl, session_id, poll_interval_ms);
+  config.token = session.token;
+  saveConfig(config);
+  console.log(`  Logged in as ${session.githubLogin}. Token saved.`);
+}
+
+export function setToken(token: string): void {
+  const config = loadConfig();
+  config.token = token;
+  saveConfig(config);
+  console.log('  Token saved.');
+}
+
+export function getPreferredServerUrl(): string {
+  return loadConfig().serverUrl ?? DEFAULT_SERVER_URL;
+}
+
+function getRequiredRemoteConfig(): Required<Config> {
+  const config = loadConfig();
+  if (!config.serverUrl || !config.token) {
+    throw new Error(`Not logged in. Run: ${APP_NAME} login <server-url>`);
+  }
+  return {
+    serverUrl: config.serverUrl,
+    token: config.token,
+  };
+}
+
+export async function pullFromServer(): Promise<PullResponse> {
+  const config = getRequiredRemoteConfig();
+  const res = await fetch(`${config.serverUrl}/sync/pull`, {
+    headers: {
+      Authorization: `Bearer ${config.token}`,
+    },
+  });
+
+  if (!res.ok) {
+    const err = await res.json() as { error?: string };
+    throw new Error(`Pull failed: ${err.error ?? res.statusText}`);
+  }
+
+  const body = await res.json() as unknown;
+  return pullResponseSchema.parse(body);
+}
+
+export async function pushToServer(agents: CollectedAgent[]): Promise<{ synced: number }> {
+  const config = getRequiredRemoteConfig();
+  const payload = buildPushPayload(agents);
+  const res = await fetch(`${config.serverUrl}/sync/push`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${config.token}`,
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!res.ok) {
+    const err = await res.json() as { error?: string };
+    throw new Error(`Push failed: ${err.error ?? res.statusText}`);
+  }
+
+  return res.json() as Promise<{ synced: number }>;
+}

package/src/collector/sync.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { syncAll } from './sync.js';
+import { initDb, getDb, closeDb } from './db.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('syncAll', () => {
+  const testDir = path.join(os.tmpdir(), `agent-sim-sync-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'), { recursive: true });
+    fs.writeFileSync(
+      path.join(mockClaudeDir, 'sessions', '1.json'),
+      JSON.stringify({ pid: 1, sessionId: 'sync-test-1', cwd: '/test', startedAt: 1700000000000 })
+    );
+    fs.writeFileSync(
+      path.join(mockClaudeDir, 'projects', '-test', 'sync-test-1.jsonl'),
+      JSON.stringify({
+        type: 'message',
+        message: {
+          role: 'assistant', model: 'claude-opus-4-6',
+          content: [{ type: 'tool_use', name: 'Bash', id: 't1', input: {} }],
+          usage: { input_tokens: 50, output_tokens: 100 },
+        },
+        uuid: 'm1', timestamp: 1700000001000, sessionId: 'sync-test-1',
+      })
+    );
+  });
+
+  afterEach(() => {
+    closeDb();
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('inserts new agents into the database', () => {
+    const stats = syncAll({ claudeDir: mockClaudeDir, codexDir: path.join(testDir, '.codex-nonexistent') });
+    expect(stats.newAgents).toBe(1);
+
+    const db = getDb();
+    const agent = db.prepare('SELECT * FROM agents WHERE id = ?').get('sync-test-1') as any;
+    expect(agent).toBeTruthy();
+    expect(agent.name).toBeTruthy();
+    expect(agent.tool).toBe('claude-code');
+  });
+
+  it('creates clan for new project', () => {
+    syncAll({ claudeDir: mockClaudeDir, codexDir: path.join(testDir, '.codex-nonexistent') });
+
+    const db = getDb();
+    const clans = db.prepare('SELECT * FROM clans').all();
+    expect(clans.length).toBeGreaterThan(0);
+  });
+
+  it('computes maturity from token count', () => {
+    syncAll({ claudeDir: mockClaudeDir, codexDir: path.join(testDir, '.codex-nonexistent') });
+
+    const db = getDb();
+    const agent = db.prepare('SELECT maturity FROM agents WHERE id = ?').get('sync-test-1') as any;
+    expect(agent.maturity).toBe('spark');
+  });
+});

package/src/collector/sync.ts

@@ -0,0 +1,148 @@
+import os from 'os';
+import path from 'path';
+import { computeMaturity } from '@vsuryav/agent-sim-core';
+import { getDb, setWorldConfig } from './db.js';
+import { scanClaudeCode } from './claude-code.js';
+import { scanCodexCli } from './codex-cli.js';
+import { generateName } from './names.js';
+import type { CollectedAgent, PullResponse } from './types.js';
+
+const CLAN_COLORS = [
+  '#e94560', '#ffd166', '#52b788', '#a8dadc', '#e76f51',
+  '#6a4c93', '#1982c4', '#8ac926', '#ff595e', '#ffca3a',
+];
+
+export interface SyncOptions {
+  claudeDir?: string;
+  codexDir?: string;
+}
+
+export interface SyncResult {
+  newAgents: number;
+  totalAgents: number;
+}
+
+export interface UpsertResult {
+  inserted: number;
+  updated: number;
+  totalAgents: number;
+}
+
+function ensureClanColor(clan: string): void {
+  const db = getDb();
+  const existing = db.prepare('SELECT id FROM clans WHERE id = ?').get(clan);
+  if (existing) return;
+
+  const clanCount = (db.prepare('SELECT COUNT(*) as c FROM clans').get() as { c: number }).c;
+  const color = CLAN_COLORS[clanCount % CLAN_COLORS.length]!;
+  db.prepare('INSERT INTO clans (id, name, color) VALUES (?, ?, ?)').run(clan, clan, color);
+}
+
+function upsertAgentRecord(agent: CollectedAgent, emitBornEvent: boolean): 'inserted' | 'updated' {
+  const db = getDb();
+  const existing = db.prepare('SELECT id FROM agents WHERE id = ?').get(agent.id);
+  const name = generateName(agent.id);
+  const maturity = computeMaturity(agent.total_tokens);
+
+  ensureClanColor(agent.clan);
+
+  db.prepare(`
+    INSERT INTO agents (
+      id, tool, model, project, clan, created_at,
+      total_tokens, input_tokens, output_tokens, cache_tokens, reasoning_tokens,
+      duration_ms, message_count,
+      trait_builder, trait_creator, trait_explorer, trait_leader, trait_thinker, trait_scholar,
+      name, maturity
+    ) VALUES (
+      @id, @tool, @model, @project, @clan, @created_at,
+      @total_tokens, @input_tokens, @output_tokens, @cache_tokens, @reasoning_tokens,
+      @duration_ms, @message_count,
+      @trait_builder, @trait_creator, @trait_explorer, @trait_leader, @trait_thinker, @trait_scholar,
+      @name, @maturity
+    )
+    ON CONFLICT(id) DO UPDATE SET
+      tool = excluded.tool,
+      model = excluded.model,
+      project = excluded.project,
+      clan = excluded.clan,
+      created_at = excluded.created_at,
+      total_tokens = excluded.total_tokens,
+      input_tokens = excluded.input_tokens,
+      output_tokens = excluded.output_tokens,
+      cache_tokens = excluded.cache_tokens,
+      reasoning_tokens = excluded.reasoning_tokens,
+      duration_ms = excluded.duration_ms,
+      message_count = excluded.message_count,
+      trait_builder = excluded.trait_builder,
+      trait_creator = excluded.trait_creator,
+      trait_explorer = excluded.trait_explorer,
+      trait_leader = excluded.trait_leader,
+      trait_thinker = excluded.trait_thinker,
+      trait_scholar = excluded.trait_scholar,
+      name = excluded.name,
+      maturity = excluded.maturity
+  `).run({ ...agent, name, maturity });
+
+  if (!existing && emitBornEvent) {
+    db.prepare(
+      'INSERT INTO events (timestamp, agent_id, type, description) VALUES (?, ?, ?, ?)'
+    ).run(
+      agent.created_at,
+      agent.id,
+      'born',
+      `${name} arrived from a new session`,
+    );
+  }
+
+  return existing ? 'updated' : 'inserted';
+}
+
+export function upsertAgents(
+  agents: CollectedAgent[],
+  options: { emitBornEvents?: boolean } = {},
+): UpsertResult {
+  const db = getDb();
+  let inserted = 0;
+  let updated = 0;
+
+  const batch = db.transaction(() => {
+    for (const agent of agents) {
+      const outcome = upsertAgentRecord(agent, options.emitBornEvents ?? false);
+      if (outcome === 'inserted') inserted++;
+      else updated++;
+    }
+  });
+
+  batch();
+
+  const totalAgents = (db.prepare('SELECT COUNT(*) as c FROM agents').get() as { c: number }).c;
+  return { inserted, updated, totalAgents };
+}
+
+export function mergeRemoteState(remote: PullResponse): UpsertResult {
+  setWorldConfig(remote.world);
+  return upsertAgents(remote.agents, { emitBornEvents: false });
+}
+
+export function getAllAgents(): CollectedAgent[] {
+  return getDb().prepare(`
+    SELECT
+      id, tool, model, project, clan, created_at,
+      total_tokens, input_tokens, output_tokens, cache_tokens, reasoning_tokens,
+      duration_ms, message_count,
+      trait_builder, trait_creator, trait_explorer, trait_leader, trait_thinker, trait_scholar
+    FROM agents
+    ORDER BY created_at
+  `).all() as CollectedAgent[];
+}
+
+export function syncAll(opts: SyncOptions = {}): SyncResult {
+  const claudeDir = opts.claudeDir ?? path.join(os.homedir(), '.claude');
+  const codexDir = opts.codexDir ?? path.join(os.homedir(), '.codex');
+
+  const claudeAgents = scanClaudeCode(claudeDir);
+  const codexAgents = scanCodexCli(codexDir);
+  const upsert = upsertAgents([...claudeAgents, ...codexAgents], { emitBornEvents: true });
+
+  return { newAgents: upsert.inserted, totalAgents: upsert.totalAgents };
+}

package/src/collector/types.ts

@@ -0,0 +1 @@
+export type { CollectedAgent, PullResponse, UserWorldConfig } from '@vsuryav/agent-sim-contracts';

package/src/engine/bootstrap/state.ts

@@ -0,0 +1,3 @@
+// Stub — replaces host-specific interaction telemetry
+export function flushInteractionTime(): void {}
+export function updateLastInteractionTime(): void {}