vibemancer 0.1.0

package/dist/cli.js

@@ -0,0 +1,1193 @@
+#!/usr/bin/env node
+
+// src/commands/dev.ts
+import { execFile } from "child_process";
+
+// src/bot-discovery.ts
+import fs from "fs";
+import path from "path";
+async function discoverBot(projectDir, overridePath) {
+  const absDir = path.resolve(projectDir);
+  if (overridePath) {
+    const absPath = path.resolve(absDir, overridePath);
+    if (!fs.existsSync(absPath)) {
+      throw new Error(`Bot file not found: ${absPath}`);
+    }
+    const exportName = await findExportName(absPath);
+    return { sourcePath: absPath, exportName };
+  }
+  const configPath = path.join(absDir, "vibemancer.json");
+  if (fs.existsSync(configPath)) {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(raw);
+    } catch {
+      throw new Error(`Invalid JSON in vibemancer.json: ${configPath}`);
+    }
+    if (config.bot !== null && config.bot !== void 0 && typeof config.bot !== "string") {
+      throw new Error(`Invalid "bot" field in vibemancer.json: expected string, got ${typeof config.bot}`);
+    }
+    if (config.export !== null && config.export !== void 0 && typeof config.export !== "string") {
+      throw new Error(`Invalid "export" field in vibemancer.json: expected string, got ${typeof config.export}`);
+    }
+    if (config.bot) {
+      const botPath = path.resolve(absDir, config.bot);
+      if (!fs.existsSync(botPath)) {
+        throw new Error(`Bot file from vibemancer.json not found: ${botPath}`);
+      }
+      const exportName = config.export || await findExportName(botPath);
+      return { sourcePath: botPath, exportName };
+    }
+  }
+  const defaultPath = path.join(absDir, "src", "bot.ts");
+  if (fs.existsSync(defaultPath)) {
+    const exportName = await findExportName(defaultPath);
+    return { sourcePath: defaultPath, exportName };
+  }
+  throw new Error(
+    'Could not find bot source file.\nCreate src/bot.ts or add a vibemancer.json with {"bot": "path/to/bot.ts"}'
+  );
+}
+async function findExportName(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const match = content.match(/export\s+(?:function|const|class)\s+([A-Z]\w*)/);
+  if (match?.[1]) {
+    return match[1];
+  }
+  const reExport = content.match(/export\s*\{\s*([A-Z]\w*)/);
+  if (reExport?.[1]) {
+    return reExport[1];
+  }
+  throw new Error(
+    `Could not find a named export in ${filePath}.
+Bot export must start with a capital letter (PascalCase).
+Example: export function MyWizard() { ... }`
+  );
+}
+var SCAN_SKIP_FILE_PATTERNS = [
+  /\.d\.ts$/,
+  /\.test\.tsx?$/,
+  /\.spec\.tsx?$/
+];
+var SCAN_SKIP_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".cache",
+  ".turbo",
+  "__tests__"
+]);
+var SCAN_SKIP_FILE_NAMES = /* @__PURE__ */ new Set([
+  "index.ts",
+  "index.tsx",
+  "types.ts",
+  "types.tsx",
+  "helpers.ts",
+  "helpers.tsx"
+]);
+function listTsFilesRecursively(rootDir) {
+  const out = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (dir === void 0) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SCAN_SKIP_DIR_NAMES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        stack.push(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".tsx")) continue;
+      if (SCAN_SKIP_FILE_NAMES.has(entry.name)) continue;
+      if (SCAN_SKIP_FILE_PATTERNS.some((re) => re.test(entry.name))) continue;
+      out.push(full);
+    }
+  }
+  return out;
+}
+async function discoverAllBots(projectDir) {
+  const absDir = path.resolve(projectDir);
+  const srcDir = path.join(absDir, "src");
+  if (!fs.existsSync(srcDir)) return [];
+  const files = listTsFilesRecursively(srcDir);
+  const bots = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    let exportName;
+    try {
+      exportName = await findExportName(file);
+    } catch {
+      continue;
+    }
+    if (seenNames.has(exportName)) continue;
+    seenNames.add(exportName);
+    bots.push({ sourcePath: file, exportName });
+  }
+  bots.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return bots;
+}
+
+// src/server.ts
+import http from "http";
+
+// src/compile-single-bot.ts
+import { build } from "esbuild";
+
+// src/opponent-resolver.ts
+import path2 from "path";
+import fs2 from "fs";
+import { fileURLToPath } from "url";
+import { BotBundle } from "@vibemancer/core";
+function findCoreSourceDir() {
+  const monorepoCore = path2.resolve(import.meta.dirname, "..", "..", "core", "src");
+  if (fs2.existsSync(path2.join(monorepoCore, "engine", "simulation.ts"))) {
+    return monorepoCore;
+  }
+  try {
+    const coreIndex = import.meta.resolve("@vibemancer/core");
+    const coreIndexPath = fileURLToPath(coreIndex);
+    const coreRoot = path2.resolve(path2.dirname(coreIndexPath), "..");
+    const srcDir = path2.join(coreRoot, "src");
+    if (fs2.existsSync(path2.join(srcDir, "engine", "simulation.ts"))) {
+      return srcDir;
+    }
+  } catch {
+  }
+  throw new Error(
+    "Could not find @vibemancer/core source directory.\nEnsure @vibemancer/core is installed and includes its src/ directory."
+  );
+}
+var BUILTIN_BOTS = {
+  // Standalone
+  TargetDummy: "standalone/TargetDummy.ts",
+  Critter: "standalone/Critter.ts",
+  Rookie: "standalone/Rookie.ts",
+  Hogger: "standalone/Hogger.ts",
+  Doombringer: "standalone/Doombringer.ts",
+  // Defensive
+  Turtle: "defensive/01_Turtle.ts",
+  Sentinel: "defensive/02_Sentinel.ts",
+  Golem: "defensive/03_Golem.ts",
+  // Melee
+  Shadowblade: "melee/01_Shadowblade.ts",
+  Nightblade: "melee/02_Nightblade.ts",
+  Voidblade: "melee/03_Voidblade.ts",
+  // Homing
+  Bonemancer: "homing/01_Bonemancer.ts",
+  Lich: "homing/02_Lich.ts",
+  Archlich: "homing/03_Archlich.ts",
+  // Caster
+  Flamecaller: "caster/01_Flamecaller.ts",
+  Pyromancer: "caster/02_Pyromancer.ts",
+  Infernalist: "caster/03_Infernalist.ts",
+  // Sniper
+  Spellshot: "sniper/01_Spellshot.ts",
+  Spelltracer: "sniper/02_Spelltracer.ts",
+  Spellseeker: "sniper/03_Spellseeker.ts",
+  // Duelist
+  Battlemage: "duelist/01_Battlemage.ts",
+  Warmage: "duelist/02_Warmage.ts",
+  Archmage: "duelist/03_Archmage.ts",
+  // Berserker
+  Stormchaser: "berserker/01_Stormchaser.ts",
+  Stormcaller: "berserker/02_Stormcaller.ts",
+  Stormforger: "berserker/03_Stormforger.ts",
+  // Kiter
+  Spellspinner: "kiter/01_Spellspinner.ts",
+  Spellweaver: "kiter/02_Spellweaver.ts",
+  Spellbinder: "kiter/03_Spellbinder.ts"
+};
+function getCoreCompileOptions() {
+  const coreSourceDir = findCoreSourceDir();
+  return {
+    alias: {
+      "@vibemancer/core": coreSourceDir + "/index-browser.ts"
+    }
+  };
+}
+function getBuiltinBotNames() {
+  return Object.keys(BUILTIN_BOTS);
+}
+function resolveOpponent(name) {
+  const relativePath = BUILTIN_BOTS[name];
+  if (!relativePath) {
+    const available = Object.keys(BUILTIN_BOTS).join(", ");
+    throw new Error(
+      `Unknown opponent "${name}".
+Available built-in bots: ${available}`
+    );
+  }
+  const coreSourceDir = findCoreSourceDir();
+  const sourcePath = path2.join(coreSourceDir, "bots", relativePath);
+  if (!fs2.existsSync(sourcePath)) {
+    throw new Error(`Built-in bot source not found: ${sourcePath}`);
+  }
+  return new BotBundle(sourcePath, name);
+}
+
+// src/compile-single-bot.ts
+async function compileSingleBotBundle(sourcePath, exportName) {
+  const coreSourceDir = findCoreSourceDir();
+  const result = await build({
+    entryPoints: [sourcePath],
+    bundle: true,
+    write: false,
+    format: "iife",
+    globalName: "__botExport",
+    platform: "neutral",
+    target: "es2022",
+    logLevel: "error",
+    footer: { js: `globalThis.__injectedBot1 = __botExport.${exportName};` },
+    external: [
+      "isolated-vm",
+      "esbuild",
+      "node:*"
+    ],
+    alias: {
+      "@vibemancer/core": coreSourceDir + "/index-browser.ts"
+    }
+  });
+  if (!result.outputFiles?.[0]) {
+    throw new Error("esbuild produced no output");
+  }
+  return result.outputFiles[0].text;
+}
+
+// src/server.ts
+function botInfoToWire(info) {
+  return {
+    name: info.exportName,
+    exportName: info.exportName,
+    sourcePath: info.sourcePath
+  };
+}
+function startServer(options) {
+  const { port, projectDir } = options;
+  async function loadBots() {
+    return discoverAllBots(projectDir);
+  }
+  const server = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    const pathname = url.pathname;
+    try {
+      if (pathname === "/health") {
+        respond(res, 200, { status: "ok" });
+        return;
+      }
+      if (pathname === "/local-bots") {
+        const bots = await loadBots();
+        const body = { bots: bots.map(botInfoToWire) };
+        respond(res, 200, body);
+        return;
+      }
+      const bundleMatch = /^\/local-bots\/([A-Za-z_][A-Za-z0-9_]*)\/bundle$/.exec(pathname);
+      if (bundleMatch) {
+        const requestedName = bundleMatch[1];
+        const bots = await loadBots();
+        const target = bots.find((b) => b.exportName === requestedName);
+        if (!target) {
+          respond(res, 404, { error: `No local bot named "${requestedName}". Found: ${bots.map((b) => b.exportName).join(", ") || "(none)"}` });
+          return;
+        }
+        const start = Date.now();
+        const bundle = await compileSingleBotBundle(target.sourcePath, target.exportName);
+        const elapsed = Date.now() - start;
+        console.log(`  Compiled ${target.exportName} (${(bundle.length / 1024).toFixed(1)} KB) in ${elapsed}ms`);
+        res.writeHead(200, { "Content-Type": "text/javascript" });
+        res.end(bundle);
+        return;
+      }
+      respond(res, 404, { error: `Not found: ${pathname}` });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`  Error: ${message}`);
+      respond(res, 500, { error: message });
+    }
+  });
+  server.listen(port, () => {
+    console.log(`
+Vibemancer dev server running at http://localhost:${port}`);
+    void (async () => {
+      const bots = await loadBots();
+      if (bots.length === 0) {
+        console.log("  (no bots discovered in src/ \u2014 add a .ts file with a PascalCase export)");
+      } else {
+        console.log(`  Bots: ${bots.map((b) => b.exportName).join(", ")}`);
+      }
+      console.log("");
+      console.log("Open your browser to play:");
+      console.log(`  https://vibemancer.com/#botserver=localhost:${port}
+`);
+      console.log("Endpoints:");
+      console.log("  GET /local-bots                     - List of locally-discovered bots");
+      console.log("  GET /local-bots/<name>/bundle       - Compile a single bot to a sandbox-ready bundle");
+      console.log("  GET /health                         - Server health check\n");
+    })();
+  });
+  return server;
+}
+function respond(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+// src/commands/dev.ts
+async function runDev(options) {
+  const projectDir = process.cwd();
+  const bots = await discoverAllBots(projectDir);
+  if (bots.length === 0) {
+    console.log("No bots discovered in src/. Add a .ts file with a PascalCase export, e.g.:");
+    console.log("  export function MyWizard(props) { return {move: {x: 0, y: 0}}; }");
+  } else {
+    console.log(`Discovered ${bots.length} bot${bots.length === 1 ? "" : "s"}: ${bots.map((b) => b.exportName).join(", ")}`);
+  }
+  const server = startServer({
+    port: options.port,
+    projectDir
+  });
+  server.once("listening", () => {
+    const url = `https://vibemancer.com/#botserver=localhost:${options.port}`;
+    openBrowser(url);
+  });
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      execFile("open", [url], () => {
+      });
+    } else if (platform === "win32") {
+      execFile("cmd", ["/c", "start", "", url], () => {
+      });
+    } else {
+      execFile("xdg-open", [url], (err) => {
+        if (err) execFile("wslview", [url], () => {
+        });
+      });
+    }
+  } catch {
+  }
+}
+
+// src/commands/test.ts
+import { execFileSync } from "child_process";
+async function runTest(_options) {
+  console.log("\n  Running tests...\n");
+  try {
+    execFileSync("npx", ["vitest", "run"], {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/fight.ts
+import fs3 from "fs";
+import path3 from "path";
+import { BotBundle as BotBundle2, sandboxFight, scoreFight } from "@vibemancer/core";
+async function runFight(options) {
+  if (options.opponent) {
+    return runSingleFight({ ...options, opponent: options.opponent });
+  }
+  return runFullFight(options);
+}
+async function runSingleFight(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  console.log(`
+  Bot: ${botInfo.exportName}`);
+  console.log(`  Opponent: ${options.opponent}
+`);
+  const userBundle = new BotBundle2(botInfo.sourcePath, botInfo.exportName);
+  const opponentBundle = resolveOpponent(options.opponent);
+  const start = Date.now();
+  const result = await sandboxFight(userBundle, opponentBundle, {
+    seed: options.seed,
+    compileOptions: getCoreCompileOptions()
+  });
+  const elapsed = Date.now() - start;
+  const { wizard1Wins, wizard2Wins, draws } = result;
+  const total = wizard1Wins + wizard2Wins + draws;
+  const outcome = result.winner === "wizard-1" ? "WIN" : result.winner === "wizard-2" ? "LOSS" : "DRAW";
+  console.log(`  Result: ${outcome}`);
+  console.log(`  ${botInfo.exportName}: ${wizard1Wins}W  |  ${options.opponent}: ${wizard2Wins}W  |  Draws: ${draws}`);
+  console.log(`  (${total} matches in ${elapsed}ms)
+`);
+  if (result.winner === "wizard-2") {
+    process.exit(1);
+  }
+}
+async function runFullFight(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  const userBundle = new BotBundle2(botInfo.sourcePath, botInfo.exportName);
+  const opponents = getBuiltinBotNames();
+  console.log(`
+  Fighting ${botInfo.exportName} against ${opponents.length} built-in bots...
+`);
+  const entries = [];
+  const overallStart = Date.now();
+  for (const opponentName of opponents) {
+    const opponentBundle = resolveOpponent(opponentName);
+    const start = Date.now();
+    const result = await sandboxFight(userBundle, opponentBundle, {
+      seed: options.seed,
+      compileOptions: getCoreCompileOptions()
+    });
+    const elapsed = Date.now() - start;
+    const score = scoreFight(result);
+    entries.push({
+      opponent: opponentName,
+      winner: result.winner,
+      wizard1Wins: result.wizard1Wins,
+      wizard2Wins: result.wizard2Wins,
+      draws: result.draws,
+      score,
+      elapsedMs: elapsed
+    });
+    const outcome = result.winner === "wizard-1" ? "W" : result.winner === "wizard-2" ? "L" : "D";
+    const pad = opponentName.padEnd(14);
+    console.log(`  ${pad} ${outcome}  ${result.wizard1Wins}-${result.wizard2Wins}-${result.draws}  (${elapsed}ms)`);
+  }
+  const totalElapsed = Date.now() - overallStart;
+  const wins = entries.filter((e) => e.winner === "wizard-1").length;
+  const losses = entries.filter((e) => e.winner === "wizard-2").length;
+  const drawCount = entries.filter((e) => e.winner === "draw").length;
+  const totalScore = entries.reduce((sum, e) => sum + e.score, 0);
+  const maxScore = opponents.length * 17.5;
+  console.log(`
+  Summary: ${wins}W ${losses}L ${drawCount}D out of ${opponents.length} opponents`);
+  console.log(`  Score: ${totalScore.toFixed(1)} / ${maxScore.toFixed(1)} (${(totalScore / maxScore * 100).toFixed(1)}%)`);
+  console.log(`  Total time: ${(totalElapsed / 1e3).toFixed(1)}s`);
+  const history = loadHistory(projectDir);
+  const previous = history.length > 0 ? history[history.length - 1] : null;
+  if (previous && previous.botName === botInfo.exportName) {
+    showDiff(entries, previous.results);
+  }
+  const current = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    botName: botInfo.exportName,
+    results: entries,
+    summary: { wins, losses, draws: drawCount, score: totalScore, maxScore }
+  };
+  saveHistory(projectDir, history, current);
+  console.log("");
+}
+function getHistoryPath(projectDir) {
+  return path3.join(projectDir, ".vibemancer", "history.json");
+}
+function loadHistory(projectDir) {
+  const historyPath = getHistoryPath(projectDir);
+  if (!fs3.existsSync(historyPath)) return [];
+  try {
+    const raw = fs3.readFileSync(historyPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function saveHistory(projectDir, history, current) {
+  const historyPath = getHistoryPath(projectDir);
+  const dir = path3.dirname(historyPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  const updated = [...history.slice(-19), current];
+  fs3.writeFileSync(historyPath, JSON.stringify(updated, null, "	") + "\n");
+}
+function showDiff(current, previous) {
+  const prevMap = new Map(previous.map((e) => [e.opponent, e]));
+  const changes = [];
+  for (const entry of current) {
+    const prev = prevMap.get(entry.opponent);
+    if (!prev) continue;
+    const prevOutcome = prev.winner === "wizard-1" ? "W" : prev.winner === "wizard-2" ? "L" : "D";
+    const curOutcome = entry.winner === "wizard-1" ? "W" : entry.winner === "wizard-2" ? "L" : "D";
+    if (prevOutcome !== curOutcome) {
+      changes.push(`    ${entry.opponent.padEnd(14)} ${prevOutcome} -> ${curOutcome}`);
+    }
+  }
+  const prevScore = previous.reduce((sum, e) => sum + e.score, 0);
+  const curScore = current.reduce((sum, e) => sum + e.score, 0);
+  const diff = curScore - prevScore;
+  if (changes.length > 0 || Math.abs(diff) > 0.1) {
+    console.log("\n  vs last run:");
+    if (Math.abs(diff) > 0.1) {
+      const sign = diff > 0 ? "+" : "";
+      console.log(`    Score: ${sign}${diff.toFixed(1)}`);
+    }
+    for (const change of changes) {
+      console.log(change);
+    }
+  }
+}
+
+// src/commands/trace.ts
+import {
+  BotBundle as BotBundle3,
+  sandboxSimulate,
+  extractTraceEvents,
+  summarizeTrace,
+  formatTraceEvents,
+  formatTraceSummary,
+  diagnoseTrace,
+  formatDiagnosis,
+  extractStats,
+  formatStats
+} from "@vibemancer/core";
+async function runTrace(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  const userBundle = new BotBundle3(botInfo.sourcePath, botInfo.exportName);
+  const opponentBundle = resolveOpponent(options.opponent);
+  const distance = options.distance ?? 600;
+  console.log(`
+  Trace: ${botInfo.exportName} (W1) vs ${options.opponent} (W2) | distance: ${distance} | seed: ${options.seed ?? 1}
+`);
+  const result = await sandboxSimulate(userBundle, opponentBundle, {
+    seed: options.seed ?? 1,
+    spawnDistance: distance,
+    maxTicks: options.maxTicks ?? 3e3,
+    compileOptions: getCoreCompileOptions()
+  });
+  const history = result.history;
+  if (history.length === 0) {
+    console.log("  No history available.\n");
+    return;
+  }
+  const events = extractTraceEvents(history, result.errors);
+  console.log(formatTraceEvents(events));
+  const summary = summarizeTrace(events, result, botInfo.exportName, options.opponent);
+  console.log("\n" + formatTraceSummary(summary));
+  const stats = extractStats(result);
+  console.log("");
+  console.log(formatStats(stats, botInfo.exportName));
+  const tips = diagnoseTrace(events, summary);
+  if (tips.length > 0) {
+    console.log("");
+    console.log(formatDiagnosis(tips));
+  }
+  console.log("");
+}
+
+// src/commands/tournament.ts
+import { BotBundle as BotBundle4, sandboxFight as sandboxFight2, scoreFight as scoreFight2, scoreFightAsWizard2 } from "@vibemancer/core";
+async function runTournament(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  const userBundle = new BotBundle4(botInfo.sourcePath, botInfo.exportName);
+  const opponentNames = options.opponents && options.opponents.length > 0 ? options.opponents : getBuiltinBotNames();
+  const participants = [
+    { name: botInfo.exportName, bundle: userBundle }
+  ];
+  for (const name of opponentNames) {
+    participants.push({ name, bundle: resolveOpponent(name) });
+  }
+  console.log(`
+  Tournament: ${participants.length} participants (${participants.length * (participants.length - 1) / 2} pairings)
+`);
+  const pairings = [];
+  for (let i = 0; i < participants.length; i++) {
+    for (let j = i + 1; j < participants.length; j++) {
+      pairings.push({
+        bot1Name: participants[i].name,
+        bot2Name: participants[j].name,
+        bot1Bundle: participants[i].bundle,
+        bot2Bundle: participants[j].bundle
+      });
+    }
+  }
+  const results = [];
+  const overallStart = Date.now();
+  for (const pairing of pairings) {
+    const result = await sandboxFight2(pairing.bot1Bundle, pairing.bot2Bundle, {
+      compileOptions: getCoreCompileOptions()
+    });
+    results.push({
+      bot1Name: pairing.bot1Name,
+      bot2Name: pairing.bot2Name,
+      result
+    });
+    const outcome = result.winner === "wizard-1" ? `${pairing.bot1Name} wins` : result.winner === "wizard-2" ? `${pairing.bot2Name} wins` : "Draw";
+    console.log(`  ${pairing.bot1Name} vs ${pairing.bot2Name}: ${result.wizard1Wins}-${result.wizard2Wins}-${result.draws} (${outcome})`);
+  }
+  const points = /* @__PURE__ */ new Map();
+  const wins = /* @__PURE__ */ new Map();
+  for (const p of participants) {
+    points.set(p.name, 0);
+    wins.set(p.name, 0);
+  }
+  for (const r of results) {
+    const score1 = scoreFight2(r.result);
+    const score2 = scoreFightAsWizard2(r.result);
+    points.set(r.bot1Name, (points.get(r.bot1Name) ?? 0) + score1);
+    points.set(r.bot2Name, (points.get(r.bot2Name) ?? 0) + score2);
+    wins.set(r.bot1Name, (wins.get(r.bot1Name) ?? 0) + r.result.wizard1Wins);
+    wins.set(r.bot2Name, (wins.get(r.bot2Name) ?? 0) + r.result.wizard2Wins);
+  }
+  const totalElapsed = Date.now() - overallStart;
+  const standings = [...points.entries()].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return (wins.get(b[0]) ?? 0) - (wins.get(a[0]) ?? 0);
+  });
+  console.log("\n  Standings:");
+  console.log("  " + "-".repeat(40));
+  for (let i = 0; i < standings.length; i++) {
+    const [name, pts] = standings[i];
+    const w = wins.get(name) ?? 0;
+    const rank = `#${(i + 1).toString().padStart(2)}`;
+    const isUser = name === botInfo.exportName ? " *" : "";
+    console.log(`  ${rank}  ${name.padEnd(16)} ${pts.toFixed(1)} pts  ${w}W${isUser}`);
+  }
+  console.log(`
+  Total time: ${(totalElapsed / 1e3).toFixed(1)}s
+`);
+}
+
+// src/commands/optimize.ts
+import { readFileSync, writeFileSync } from "fs";
+import { BotBundle as BotBundle5, MatchSandbox, scoreFight as scoreFight3, generateCandidates, getEffectiveRange } from "@vibemancer/core";
+var USEPAR_RE = /useParam\(\s*['"](\w+)['"]\s*,\s*([^,)]+?)\s*(?:,\s*\{([^}]*)\})?\s*\)/g;
+function parseNumValue(s) {
+  const n = parseFloat(s.trim());
+  if (Number.isNaN(n)) throw new Error(`useParam default is not a number: "${s.trim()}"`);
+  return n;
+}
+function parseParams(source) {
+  const params = [];
+  const re = new RegExp(USEPAR_RE.source, "g");
+  let match;
+  while ((match = re.exec(source)) !== null) {
+    const name = match[1];
+    const defaultValue = parseNumValue(match[2]);
+    const optsStr = match[3];
+    let min;
+    let max;
+    let step;
+    if (optsStr) {
+      const minMatch = optsStr.match(/min\s*:\s*([^,}]+)/);
+      const maxMatch = optsStr.match(/max\s*:\s*([^,}]+)/);
+      const stepMatch = optsStr.match(/step\s*:\s*([^,}]+)/);
+      if (minMatch) min = parseNumValue(minMatch[1]);
+      if (maxMatch) max = parseNumValue(maxMatch[1]);
+      if (stepMatch) step = parseNumValue(stepMatch[1]);
+    }
+    params.push({ name, defaultValue, min, max, step });
+  }
+  return params;
+}
+function toParamDeclaration(p) {
+  return {
+    name: p.name,
+    value: p.defaultValue,
+    min: p.min,
+    max: p.max,
+    steps: p.step ?? 5
+  };
+}
+var SPAWN_DISTANCES = [200, 300, 400, 500, 600];
+var SEEDS = [42, 137, 256];
+function runFightWithParams(sandbox, params1) {
+  let w1 = 0;
+  let w2 = 0;
+  let draws = 0;
+  const matches = [];
+  for (const seed of SEEDS) {
+    for (const dist of SPAWN_DISTANCES) {
+      const r = sandbox.simulate({
+        seed,
+        spawnDistance: dist,
+        skipHistory: true,
+        params1
+      });
+      if (r.winner === "wizard-1") w1++;
+      else if (r.winner === "wizard-2") w2++;
+      else draws++;
+      matches.push(r);
+    }
+  }
+  return {
+    wizard1Wins: w1,
+    wizard2Wins: w2,
+    draws,
+    winner: w1 > w2 ? "wizard-1" : w2 > w1 ? "wizard-2" : "draw",
+    matches
+  };
+}
+async function evaluateParams(userBundle, opponentBundles, params1) {
+  let totalScore = 0;
+  for (const opponent of opponentBundles) {
+    const sandbox = await MatchSandbox.create(userBundle, opponent, {
+      compileOptions: getCoreCompileOptions()
+    });
+    try {
+      const result = runFightWithParams(sandbox, params1);
+      totalScore += scoreFight3(result);
+    } finally {
+      sandbox.dispose();
+    }
+  }
+  return totalScore;
+}
+function resolveOpponentNames(opponents) {
+  if (!opponents || opponents.length === 0) {
+    return getBuiltinBotNames();
+  }
+  const allNames = getBuiltinBotNames();
+  for (const name of opponents) {
+    if (!allNames.includes(name)) {
+      throw new Error(
+        `Unknown opponent: "${name}". Available bots:
+  ${allNames.join(", ")}`
+      );
+    }
+  }
+  return opponents;
+}
+async function runOptimize(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  const source = readFileSync(botInfo.sourcePath, "utf-8");
+  const params = parseParams(source);
+  if (params.length === 0) {
+    console.log("\n  No useParam() calls found in your bot.");
+    console.log('  Add useParam("paramName", defaultValue, {min, max}) to enable optimization.\n');
+    return;
+  }
+  console.log(`
+  Bot: ${botInfo.exportName}`);
+  console.log(`  Parameters: ${params.length}`);
+  params.forEach((p) => console.log(`    ${p.name} = ${p.defaultValue} [${p.min ?? "auto"} .. ${p.max ?? "auto"}]`));
+  const steps = options.steps ?? 5;
+  const maxRounds = options.rounds ?? 3;
+  const opponentNames = resolveOpponentNames(options.opponents);
+  const opponentBundles = opponentNames.map((name) => resolveOpponent(name));
+  const userBundle = new BotBundle5(botInfo.sourcePath, botInfo.exportName);
+  console.log(`  Opponents: ${opponentBundles.length}`);
+  console.log(`  Steps per param: ${steps}`);
+  console.log(`  Max rounds: ${maxRounds}
+`);
+  const best = {};
+  for (const p of params) best[p.name] = p.defaultValue;
+  let bestScore = await evaluateParams(userBundle, opponentBundles, best);
+  console.log(`  Baseline score: ${bestScore.toFixed(1)} / ${(opponentBundles.length * SPAWN_DISTANCES.length * SEEDS.length * 3.5).toFixed(1)}
+`);
+  for (let round = 0; round < maxRounds; round++) {
+    let improved = false;
+    console.log(`  Round ${round + 1}:`);
+    for (const p of params) {
+      const decl = toParamDeclaration(p);
+      const range = getEffectiveRange(decl);
+      const candidates = generateCandidates(range.min, range.max, steps);
+      let paramBest = best[p.name];
+      let paramBestScore = bestScore;
+      for (const candidate of candidates) {
+        if (Math.abs(candidate - paramBest) < 1e-3) continue;
+        const trial = { ...best, [p.name]: candidate };
+        const score = await evaluateParams(userBundle, opponentBundles, trial);
+        if (score > paramBestScore) {
+          paramBest = candidate;
+          paramBestScore = score;
+        }
+      }
+      if (paramBest !== best[p.name]) {
+        console.log(`    ${p.name}: ${best[p.name]} -> ${paramBest} (+${(paramBestScore - bestScore).toFixed(1)})`);
+        best[p.name] = paramBest;
+        bestScore = paramBestScore;
+        improved = true;
+      } else {
+        console.log(`    ${p.name}: ${best[p.name]} (no improvement)`);
+      }
+    }
+    if (!improved) {
+      console.log("  No improvements found, stopping.\n");
+      break;
+    }
+    console.log(`  Round ${round + 1} score: ${bestScore.toFixed(1)}
+`);
+  }
+  let updated = source;
+  for (const p of params) {
+    const newVal = best[p.name];
+    if (newVal !== p.defaultValue) {
+      const pattern = new RegExp(
+        `(useParam\\(\\s*['"]${escapeRegex(p.name)}['"]\\s*,\\s*)${escapeRegex(String(p.defaultValue))}`
+      );
+      updated = updated.replace(pattern, `$1${newVal}`);
+    }
+  }
+  if (updated !== source) {
+    writeFileSync(botInfo.sourcePath, updated);
+    console.log(`  Source updated: ${botInfo.sourcePath}`);
+  } else {
+    console.log("  No parameter changes to write.");
+  }
+  console.log(`  Final score: ${bestScore.toFixed(1)} / ${(opponentBundles.length * SPAWN_DISTANCES.length * SEEDS.length * 3.5).toFixed(1)}
+`);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/build.ts
+import fs4 from "fs";
+import path4 from "path";
+import { BotBundle as BotBundle6, compileMatchBundle } from "@vibemancer/core";
+async function runBuild(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  const coreSourceDir = findCoreSourceDir();
+  const userBundle = new BotBundle6(botInfo.sourcePath, botInfo.exportName);
+  const opponentBundle = resolveOpponent(options.opponent);
+  console.log(`
+  Compiling ${botInfo.exportName} vs ${options.opponent}...`);
+  const start = Date.now();
+  const bundle = await compileMatchBundle(userBundle, opponentBundle, {
+    alias: {
+      "@vibemancer/core": coreSourceDir + "/index-browser.ts"
+    }
+  });
+  const elapsed = Date.now() - start;
+  const outFile = options.output ?? `dist/${botInfo.exportName}-vs-${options.opponent}.js`;
+  const outDir = path4.dirname(path4.resolve(outFile));
+  fs4.mkdirSync(outDir, { recursive: true });
+  fs4.writeFileSync(path4.resolve(outFile), bundle);
+  const sizeKb = (bundle.length / 1024).toFixed(1);
+  console.log(`  Output: ${outFile} (${sizeKb} KB)`);
+  console.log(`  Compiled in ${elapsed}ms
+`);
+}
+
+// src/commands/bots.ts
+import { BOT_GROUPS, ALL_BOTS } from "@vibemancer/core";
+function runBots(options) {
+  if (options.name) {
+    showBotDetail(options.name);
+    return;
+  }
+  listAllBots();
+}
+function listAllBots() {
+  console.log("\n  Built-in Bots (29 total, ranked weakest \u2192 strongest)\n");
+  for (const group of BOT_GROUPS) {
+    console.log(`  ${group.label}:`);
+    for (const bot of group.bots) {
+      const rank = ALL_BOTS.indexOf(bot) + 1;
+      const tierLabel = bot.tier ? `T${bot.tier}` : "  ";
+      const rankStr = `#${String(rank).padStart(2)}`;
+      console.log(`    ${rankStr} ${tierLabel} ${bot.name.padEnd(14)} ${bot.description}`);
+    }
+    console.log("");
+  }
+}
+function showBotDetail(name) {
+  const bot = ALL_BOTS.find((b) => b.name.toLowerCase() === name.toLowerCase());
+  if (!bot) {
+    const available = ALL_BOTS.map((b) => b.name).join(", ");
+    console.error(`
+  Unknown bot: "${name}"
+  Available: ${available}
+`);
+    process.exit(1);
+  }
+  const rank = ALL_BOTS.indexOf(bot) + 1;
+  console.log(`
+  ${bot.name}`);
+  console.log(`  ${"\u2500".repeat(40)}`);
+  console.log(`  Rank:        #${rank} of ${ALL_BOTS.length}`);
+  console.log(`  Group:       ${bot.group}`);
+  if (bot.tier) console.log(`  Tier:        ${bot.tier} of 3`);
+  console.log(`  Description: ${bot.description}`);
+  console.log(`  Style:       ${getStyleDescription(bot)}`);
+  if (bot.tier && bot.group !== "Standalone") {
+    const groupBots = BOT_GROUPS.find((g) => g.label === bot.group)?.bots ?? [];
+    if (groupBots.length > 1) {
+      console.log(`
+  ${bot.group} progression:`);
+      for (const gb of groupBots) {
+        const gbRank = ALL_BOTS.indexOf(gb) + 1;
+        const marker = gb.name === bot.name ? " \u2190" : "";
+        console.log(`    T${gb.tier} ${gb.name.padEnd(14)} #${gbRank} \u2014 ${gb.description}${marker}`);
+      }
+    }
+  }
+  console.log(`
+  To fight:  vibemancer fight --opponent ${bot.name}`);
+  console.log(`  To trace:  vibemancer trace --opponent ${bot.name}
+`);
+}
+function getStyleDescription(bot) {
+  switch (bot.group) {
+    case "Standalone":
+      if (bot.name === "TargetDummy") return "Does nothing. Use for basic testing.";
+      if (bot.name === "Critter") return "Random actions. Tests handling of unpredictable opponents.";
+      if (bot.name === "Rookie") return "Simple homing missiles. Good first benchmark.";
+      if (bot.name === "Hogger") return "Random but with real damage. Chaos test.";
+      if (bot.name === "Doombringer") return "One huge missile. Tests shield timing.";
+      return bot.description;
+    case "Defensive":
+      return "Prioritizes shields and survival. Punishes aggression with counter-missiles. Weak to chip damage and shield baiting.";
+    case "Melee":
+      return "Blinks in close, fires fast low-range stabs. Weak to kiting and ranged pressure.";
+    case "Homing":
+      return "Slow tracking missiles that are hard to dodge. Weak to shields and fast burst.";
+    case "Caster":
+      return "Medium-range homing with adaptive missile fitting. Balanced offense and defense.";
+    case "Sniper":
+      return "Intercept-predicted straight shots. High accuracy, weak to erratic movement.";
+    case "Duelist":
+      return "Close-range fighters with balanced offense/defense. Jack of all trades.";
+    case "Berserker":
+      return "Aggressive traders who close distance fast. Weak to kiting and strong defense.";
+    case "Kiter":
+      return "Maintains distance while firing homing missiles. Weak to fast closers and blink gap-close.";
+    default:
+      return bot.description;
+  }
+}
+
+// src/commands/upload.ts
+import { createHash } from "crypto";
+async function runUpload(options) {
+  const projectDir = process.cwd();
+  const botInfo = await discoverBot(projectDir, options.bot);
+  console.log(`
+  Compiling ${botInfo.exportName}...`);
+  const bundle = await compileSingleBotBundle(botInfo.sourcePath, botInfo.exportName);
+  const sizeKb = (bundle.length / 1024).toFixed(1);
+  console.log(`  Bundle: ${sizeKb} KB`);
+  if (bundle.length > 500 * 1024) {
+    console.error(`  Error: Bundle too large (${sizeKb} KB). Max 500 KB.`);
+    process.exit(1);
+  }
+  const nameMatch = bundle.match(/export\s+(?:const|var|let)\s+name\s*=\s*["']([^"']+)["']/);
+  const wizardName = nameMatch?.[1] ?? botInfo.exportName;
+  const bundleHash = createHash("sha256").update(bundle).digest("hex");
+  console.log(`  Wizard: ${wizardName}`);
+  console.log(`  Hash: ${bundleHash.slice(0, 12)}...`);
+  console.log("  Uploading to VibeMancer...");
+  try {
+    const { initializeApp } = await import("firebase/app");
+    const { getFunctions, httpsCallable } = await import("firebase/functions");
+    const app = initializeApp({
+      apiKey: "AIzaSyDSUJ2jlk5_vlpGOypMtvqKjHhDmbgomIY",
+      authDomain: "le-vibemancer.firebaseapp.com",
+      projectId: "le-vibemancer"
+    });
+    const functions = getFunctions(app, "us-central1");
+    const uploadFn = httpsCallable(functions, "uploadWizard");
+    const result = await uploadFn({
+      bundle,
+      name: wizardName,
+      exportName: botInfo.exportName
+    });
+    const data = result.data;
+    if (data.active) {
+      if (data.reactivated) {
+        console.log(`  \u21BA ${data.message}`);
+      } else {
+        console.log(`  \u2713 ${data.message}`);
+      }
+      console.log(`  Wizard ID: ${data.wizardId}`);
+      console.log(`  Your wizard "${wizardName}" is now competing.
+`);
+    } else {
+      console.error(`  \u2717 ${data.message}`);
+      console.error("  Fix the error and try again.\n");
+      process.exit(1);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`  \u2717 Upload failed: ${message}
+`);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function parseFlag(flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+function parseIntFlag(flag, fallback) {
+  const str = parseFlag(flag);
+  if (str === void 0) return fallback;
+  const n = parseInt(str, 10);
+  if (Number.isNaN(n)) {
+    console.error(`Error: ${flag} must be a number, got "${str}".`);
+    process.exit(1);
+  }
+  return n;
+}
+function printHelp() {
+  console.log(`
+Vibemancer CLI - Development tools for wizard bots
+
+Usage:
+  vibemancer <command> [options]
+
+Commands:
+  dev          Start the development server (auto-opens browser)
+  test         Run your test suite (vitest)
+  fight        Fight against all 29 built-in bots (or a single opponent)
+  bots         List all built-in bots with descriptions
+  trace        Per-tick debug trace of a single match
+  tournament   Round-robin tournament between your bot + selected opponents
+  optimize     Optimize bot parameters via coordinate descent
+  build        Compile bot to a standalone bundle
+  upload       Upload bot to VibeMancer for online competition
+
+Common options:
+  --bot <path>   Path to bot source file (default: auto-discover)
+
+Dev options:
+  --port <n>     Server port (default: 4242)
+
+Fight options:
+  --opponent <name>   Fight a single opponent instead of all bots
+  --seed <n>          Random seed
+
+Trace options:
+  --opponent <name>   Opponent bot name (required)
+  --seed <n>          Random seed (default: 1)
+  --distance <n>      Spawn distance (default: 600)
+
+Build options:
+  --opponent <name>   Opponent bot name (required)
+  --output <path>     Output file path (default: dist/<Bot>-vs-<Opponent>.js)
+
+Optimize options:
+  --steps <n>         Candidates per parameter (default: 5)
+  --rounds <n>        Max optimization rounds (default: 3)
+  --opponents <list>  Comma-separated bot names to optimize against (default: all)
+
+Examples:
+  vibemancer dev
+  vibemancer test
+  vibemancer fight
+  vibemancer fight --opponent Battlemage
+  vibemancer trace --opponent Battlemage
+  vibemancer trace --opponent Nightblade --distance 300
+  vibemancer tournament Battlemage Warmage Archmage
+  vibemancer optimize
+  vibemancer build --opponent Battlemage
+`);
+}
+async function main() {
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  switch (command) {
+    case "dev": {
+      const port = parseIntFlag("--port", 4242);
+      const bot = parseFlag("--bot");
+      await runDev({ port, bot });
+      break;
+    }
+    case "test": {
+      const bot = parseFlag("--bot");
+      await runTest({ bot });
+      break;
+    }
+    case "fight": {
+      const opponent = parseFlag("--opponent");
+      const bot = parseFlag("--bot");
+      const seed = parseFlag("--seed") !== void 0 ? parseIntFlag("--seed", 0) : void 0;
+      await runFight({ opponent, bot, seed });
+      break;
+    }
+    case "trace": {
+      const opponent = parseFlag("--opponent");
+      if (!opponent) {
+        console.error("Error: --opponent is required for trace command.");
+        console.error("Usage: vibemancer trace --opponent Battlemage");
+        process.exit(1);
+      }
+      const bot = parseFlag("--bot");
+      const seed = parseFlag("--seed") !== void 0 ? parseIntFlag("--seed", 0) : void 0;
+      const distance = parseFlag("--distance") !== void 0 ? parseIntFlag("--distance", 600) : void 0;
+      await runTrace({ opponent, bot, seed, distance });
+      break;
+    }
+    case "bots": {
+      const name = parseFlag("--name") ?? args[1];
+      runBots({ name: name?.startsWith("--") ? void 0 : name });
+      break;
+    }
+    case "tournament": {
+      const bot = parseFlag("--bot");
+      const flagIndices = /* @__PURE__ */ new Set();
+      for (let i = 1; i < args.length; i++) {
+        if (args[i].startsWith("--")) {
+          flagIndices.add(i);
+          flagIndices.add(i + 1);
+        }
+      }
+      const opponents = args.slice(1).filter((_, i) => !flagIndices.has(i + 1));
+      await runTournament({ opponents, bot });
+      break;
+    }
+    case "optimize": {
+      const bot = parseFlag("--bot");
+      const opponentsStr = parseFlag("--opponents");
+      const opponents = opponentsStr ? opponentsStr.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+      await runOptimize({
+        bot,
+        steps: parseFlag("--steps") !== void 0 ? parseIntFlag("--steps", 5) : void 0,
+        rounds: parseFlag("--rounds") !== void 0 ? parseIntFlag("--rounds", 3) : void 0,
+        opponents
+      });
+      break;
+    }
+    case "build": {
+      const opponent = parseFlag("--opponent");
+      if (!opponent) {
+        console.error("Error: --opponent is required for build command.");
+        console.error("Usage: vibemancer build --opponent Battlemage");
+        process.exit(1);
+      }
+      const bot = parseFlag("--bot");
+      const output = parseFlag("--output");
+      await runBuild({ opponent, bot, output });
+      break;
+    }
+    case "upload": {
+      const bot = parseFlag("--bot");
+      await runUpload({ bot });
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error("Error:", error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map