vibemancer 0.1.3 → 0.1.5

package/dist/cli.js

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
+import {
+  findCoreSourceDir,
+  getBuiltinBotNames,
+  getCoreCompileOptions,
+  resolveOpponent
+} from "./chunk-4DUS7IHW.js";
+import {
+  FIREBASE_CONFIG
+} from "./chunk-AA2UJPPN.js";
 
 // src/commands/dev.ts
 import { execFile } from "child_process";
@@ -40,13 +49,25 @@ async function discoverBot(projectDir, overridePath) {
       return { sourcePath: botPath, exportName };
     }
   }
+  const allBots = await discoverAllBots(absDir);
+  if (allBots.length === 1) {
+    return allBots[0];
+  }
+  if (allBots.length > 1) {
+    const list = allBots.map((b) => `  --bot ${path.relative(absDir, b.sourcePath).replace(/\\/g, "/")}  (${b.exportName})`).join("\n");
+    throw new Error(
+      `Found ${allBots.length} bots. Pick one with --bot:
+
+${list}`
+    );
+  }
   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"}'
+    "Could not find bot source file.\nCreate a .ts file in src/ with a PascalCase export, e.g.:\n  export function MyWizard() { ... }"
   );
 }
 async function findExportName(filePath) {
@@ -142,100 +163,6 @@ 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({
@@ -355,7 +282,7 @@ async function runDev(options) {
   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}}; }");
+    console.log("  export function MyWizard() { return move(0, 0); }");
   } else {
     console.log(`Discovered ${bots.length} bot${bots.length === 1 ? "" : "s"}: ${bots.map((b) => b.exportName).join(", ")}`);
   }
@@ -402,9 +329,70 @@ async function runTest(_options) {
 }
 
 // src/commands/fight.ts
-import fs3 from "fs";
-import path3 from "path";
-import { BotBundle as BotBundle2, sandboxFight, scoreFight } from "@vibemancer/core";
+import fs2 from "fs";
+import path2 from "path";
+import { BotBundle, sandboxFight, scoreFight, runBundleFight } from "@vibemancer/core";
+
+// src/remote-opponent.ts
+import { initializeApp, getApps } from "firebase/app";
+import { getFirestore, collection, query, where, limit, getDocs, connectFirestoreEmulator } from "firebase/firestore";
+import { getStorage, ref, getBytes, connectStorageEmulator } from "firebase/storage";
+function isHandleSelector(opponent) {
+  const trimmed = opponent.trim();
+  const slash = trimmed.indexOf("/");
+  return slash > 0 && slash < trimmed.length - 1;
+}
+var cachedDb = null;
+var cachedStorage = null;
+function getApp() {
+  const apps = getApps();
+  return apps.length > 0 ? apps[0] : initializeApp(FIREBASE_CONFIG);
+}
+function getDb() {
+  if (!cachedDb) {
+    cachedDb = getFirestore(getApp());
+    if (process.env.VIBEMANCER_EMULATOR === "1") connectFirestoreEmulator(cachedDb, "127.0.0.1", 8085);
+  }
+  return cachedDb;
+}
+function getBucket() {
+  if (!cachedStorage) {
+    cachedStorage = getStorage(getApp());
+    if (process.env.VIBEMANCER_EMULATOR === "1") connectStorageEmulator(cachedStorage, "127.0.0.1", 9199);
+  }
+  return cachedStorage;
+}
+async function resolveRemoteOpponent(selector) {
+  const slash = selector.indexOf("/");
+  const handle = selector.slice(0, slash).trim().toLowerCase();
+  const botName = selector.slice(slash + 1).trim();
+  if (!handle || !botName) {
+    throw new Error(`Invalid opponent "${selector}" \u2014 expected handle/botname (e.g. happy-golden-banana/FireMage).`);
+  }
+  const db = getDb();
+  const snap = await getDocs(query(
+    collection(db, "wizards"),
+    where("ownerHandle", "==", handle),
+    where("nameLower", "==", botName.toLowerCase()),
+    where("active", "==", true),
+    limit(1)
+  ));
+  if (snap.empty) {
+    throw new Error(`No active bot "${botName}" found for handle "${handle}". Check the handle + bot name (both case-insensitive) on the leaderboard.`);
+  }
+  const docSnap = snap.docs[0];
+  const data = docSnap.data();
+  const exportName = typeof data.exportName === "string" ? data.exportName : "";
+  if (!exportName) {
+    throw new Error(`Bot "${handle}/${botName}" is missing its export name.`);
+  }
+  const bundlePath = typeof data.bundlePath === "string" ? data.bundlePath : `bundles/${docSnap.id}.js`;
+  const bytes = await getBytes(ref(getBucket(), bundlePath));
+  const bundle = new TextDecoder().decode(bytes);
+  return { bundle, exportName, label: `${handle}/${botName}` };
+}
+
+// src/commands/fight.ts
 async function runFight(options) {
   if (options.opponent) {
     return runSingleFight({ ...options, opponent: options.opponent });
@@ -418,13 +406,21 @@ async function runSingleFight(options) {
   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()
-  });
+  let result;
+  if (isHandleSelector(options.opponent)) {
+    console.log("  Resolving uploaded opponent...");
+    const remote = await resolveRemoteOpponent(options.opponent);
+    const userBundle = await compileSingleBotBundle(botInfo.sourcePath, botInfo.exportName);
+    result = await runBundleFight(userBundle, remote.bundle, { seed: options.seed ?? 1 });
+  } else {
+    const userBundle = new BotBundle(botInfo.sourcePath, botInfo.exportName);
+    const opponentBundle = resolveOpponent(options.opponent);
+    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;
@@ -440,7 +436,7 @@ async function runSingleFight(options) {
 async function runFullFight(options) {
   const projectDir = process.cwd();
   const botInfo = await discoverBot(projectDir, options.bot);
-  const userBundle = new BotBundle2(botInfo.sourcePath, botInfo.exportName);
+  const userBundle = new BotBundle(botInfo.sourcePath, botInfo.exportName);
   const opponents = getBuiltinBotNames();
   console.log(`
   Fighting ${botInfo.exportName} against ${opponents.length} built-in bots...
@@ -494,13 +490,13 @@ async function runFullFight(options) {
   console.log("");
 }
 function getHistoryPath(projectDir) {
-  return path3.join(projectDir, ".vibemancer", "history.json");
+  return path2.join(projectDir, ".vibemancer", "history.json");
 }
 function loadHistory(projectDir) {
   const historyPath = getHistoryPath(projectDir);
-  if (!fs3.existsSync(historyPath)) return [];
+  if (!fs2.existsSync(historyPath)) return [];
   try {
-    const raw = fs3.readFileSync(historyPath, "utf-8");
+    const raw = fs2.readFileSync(historyPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -508,10 +504,10 @@ function loadHistory(projectDir) {
 }
 function saveHistory(projectDir, history, current) {
   const historyPath = getHistoryPath(projectDir);
-  const dir = path3.dirname(historyPath);
-  fs3.mkdirSync(dir, { recursive: true });
+  const dir = path2.dirname(historyPath);
+  fs2.mkdirSync(dir, { recursive: true });
   const updated = [...history.slice(-19), current];
-  fs3.writeFileSync(historyPath, JSON.stringify(updated, null, "	") + "\n");
+  fs2.writeFileSync(historyPath, JSON.stringify(updated, null, "	") + "\n");
 }
 function showDiff(current, previous) {
   const prevMap = new Map(previous.map((e) => [e.opponent, e]));
@@ -542,8 +538,9 @@ function showDiff(current, previous) {
 
 // src/commands/trace.ts
 import {
-  BotBundle as BotBundle3,
+  BotBundle as BotBundle2,
   sandboxSimulate,
+  runBundleSimulate,
   extractTraceEvents,
   summarizeTrace,
   formatTraceEvents,
@@ -556,18 +553,30 @@ import {
 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()
-  });
+  let result;
+  if (isHandleSelector(options.opponent)) {
+    console.log("  Resolving uploaded opponent...");
+    const remote = await resolveRemoteOpponent(options.opponent);
+    const userBundle = await compileSingleBotBundle(botInfo.sourcePath, botInfo.exportName);
+    result = await runBundleSimulate(userBundle, remote.bundle, {
+      seed: options.seed ?? 1,
+      spawnDistance: distance,
+      maxTicks: options.maxTicks ?? 3e3
+    });
+  } else {
+    const userBundle = new BotBundle2(botInfo.sourcePath, botInfo.exportName);
+    const opponentBundle = resolveOpponent(options.opponent);
+    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");
@@ -589,11 +598,11 @@ async function runTrace(options) {
 }
 
 // src/commands/tournament.ts
-import { BotBundle as BotBundle4, sandboxFight as sandboxFight2, scoreFight as scoreFight2, scoreFightAsWizard2 } from "@vibemancer/core";
+import { BotBundle as BotBundle3, 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 userBundle = new BotBundle3(botInfo.sourcePath, botInfo.exportName);
   const opponentNames = options.opponents && options.opponents.length > 0 ? options.opponents : getBuiltinBotNames();
   const participants = [
     { name: botInfo.exportName, bundle: userBundle }
@@ -664,7 +673,7 @@ async function runTournament(options) {
 
 // src/commands/optimize.ts
 import { readFileSync, writeFileSync } from "fs";
-import { BotBundle as BotBundle5, MatchSandbox, scoreFight as scoreFight3, generateCandidates, getEffectiveRange } from "@vibemancer/core";
+import { BotBundle as BotBundle4, 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());
@@ -780,7 +789,7 @@ async function runOptimize(options) {
   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);
+  const userBundle = new BotBundle4(botInfo.sourcePath, botInfo.exportName);
   console.log(`  Opponents: ${opponentBundles.length}`);
   console.log(`  Steps per param: ${steps}`);
   console.log(`  Max rounds: ${maxRounds}
@@ -848,14 +857,14 @@ function escapeRegex(s) {
 }
 
 // src/commands/build.ts
-import fs4 from "fs";
-import path4 from "path";
-import { BotBundle as BotBundle6, compileMatchBundle } from "@vibemancer/core";
+import fs3 from "fs";
+import path3 from "path";
+import { BotBundle as BotBundle5, 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 userBundle = new BotBundle5(botInfo.sourcePath, botInfo.exportName);
   const opponentBundle = resolveOpponent(options.opponent);
   console.log(`
   Compiling ${botInfo.exportName} vs ${options.opponent}...`);
@@ -867,9 +876,9 @@ async function runBuild(options) {
   });
   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 outDir = path3.dirname(path3.resolve(outFile));
+  fs3.mkdirSync(outDir, { recursive: true });
+  fs3.writeFileSync(path3.resolve(outFile), bundle);
   const sizeKb = (bundle.length / 1024).toFixed(1);
   console.log(`  Output: ${outFile} (${sizeKb} KB)`);
   console.log(`  Compiled in ${elapsed}ms
@@ -966,7 +975,7 @@ function getStyleDescription(bot) {
 
 // src/commands/upload.ts
 import { createHash } from "crypto";
-import fs5 from "fs";
+import fs4 from "fs";
 async function runUpload(options) {
   const projectDir = process.cwd();
   const botInfo = await discoverBot(projectDir, options.bot);
@@ -979,25 +988,21 @@ async function runUpload(options) {
     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 wizardName = 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 { initializeApp: initializeApp2 } = 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 { FIREBASE_CONFIG: FIREBASE_CONFIG2 } = await import("./firebase-config-F6COE3NY.js");
+    const app = initializeApp2(FIREBASE_CONFIG2);
     const functions = getFunctions(app, "us-central1");
     const uploadFn = httpsCallable(functions, "uploadWizard");
     let sourceCode;
     try {
-      sourceCode = fs5.readFileSync(botInfo.sourcePath, "utf-8");
+      sourceCode = fs4.readFileSync(botInfo.sourcePath, "utf-8");
     } catch {
     }
     const result = await uploadFn({
@@ -1030,38 +1035,47 @@ async function runUpload(options) {
 }
 
 // src/commands/pull.ts
-import fs6 from "fs";
+import fs5 from "fs";
 async function runPull(options) {
   const projectDir = process.cwd();
   const botInfo = await discoverBot(projectDir, options.bot);
   console.log(`
   Pulling latest source for ${botInfo.exportName}...`);
   try {
-    const { initializeApp } = await import("firebase/app");
+    const { initializeApp: initializeApp2 } = await import("firebase/app");
     const { getAuth, signInWithPopup, GoogleAuthProvider } = await import("firebase/auth");
-    const { getFirestore, collection, query, where, getDocs, doc, getDoc, limit: fbLimit } = await import("firebase/firestore");
-    const app = initializeApp({
-      apiKey: "AIzaSyDSUJ2jlk5_vlpGOypMtvqKjHhDmbgomIY",
-      authDomain: "le-vibemancer.firebaseapp.com",
-      projectId: "le-vibemancer"
-    });
+    const { getFirestore: getFirestore2, collection: collection2, query: query2, where: where2, getDocs: getDocs2, doc, getDoc, limit: fbLimit } = await import("firebase/firestore");
+    const { FIREBASE_CONFIG: FIREBASE_CONFIG2 } = await import("./firebase-config-F6COE3NY.js");
+    const app = initializeApp2(FIREBASE_CONFIG2);
     const auth = getAuth(app);
     console.log("  Signing in...");
     const cred = await signInWithPopup(auth, new GoogleAuthProvider());
     const userId = cred.user.uid;
     console.log(`  Signed in as ${cred.user.displayName ?? cred.user.email ?? userId}`);
-    const db = getFirestore(app);
-    const wizardQuery = query(
-      collection(db, "wizards"),
-      where("ownerId", "==", userId),
-      where("name", "==", botInfo.exportName),
-      where("active", "==", true),
+    const db = getFirestore2(app);
+    const wizardSnap = await getDocs2(query2(
+      collection2(db, "wizards"),
+      where2("ownerId", "==", userId),
+      where2("name", "==", botInfo.exportName),
+      where2("active", "==", true),
       fbLimit(1)
-    );
-    const wizardSnap = await getDocs(wizardQuery);
+    ));
     if (wizardSnap.empty) {
-      console.error(`  No active wizard named "${botInfo.exportName}" found on your account.`);
-      console.error("  Upload first with: vibemancer upload");
+      const allBots = await getDocs2(query2(
+        collection2(db, "wizards"),
+        where2("ownerId", "==", userId),
+        where2("active", "==", true),
+        fbLimit(20)
+      ));
+      if (allBots.empty) {
+        console.error("  No active wizards found on your account.");
+        console.error("  Upload first with: vibemancer upload");
+      } else {
+        const names = allBots.docs.map((d) => d.data().name).filter(Boolean);
+        console.error(`  No wizard named "${botInfo.exportName}" found. Your active wizards:`);
+        for (const n of names) console.error(`    - ${n}`);
+        console.error("\n  Rename your local export to match, or upload first.");
+      }
       process.exit(1);
     }
     const wizardId = wizardSnap.docs[0].id;
@@ -1077,7 +1091,7 @@ async function runPull(options) {
       console.error("  Source code is empty. Re-upload to store it.");
       process.exit(1);
     }
-    fs6.writeFileSync(botInfo.sourcePath, sourceCode);
+    fs5.writeFileSync(botInfo.sourcePath, sourceCode);
     console.log(`  \u2713 Updated ${botInfo.sourcePath}`);
     console.log(`  ${(sourceCode.length / 1024).toFixed(1)} KB written`);
   } catch (err) {
@@ -1090,6 +1104,60 @@ async function runPull(options) {
   }
 }
 
+// src/commands/feedback.ts
+async function runFeedback(options) {
+  const message = options.message.trim();
+  if (!message) {
+    console.error("  Error: feedback message cannot be empty.");
+    process.exit(1);
+  }
+  console.log("\n  Submitting feedback...");
+  try {
+    const { initializeApp: initializeApp2 } = await import("firebase/app");
+    const { getFunctions, httpsCallable } = await import("firebase/functions");
+    const { FIREBASE_CONFIG: FIREBASE_CONFIG2 } = await import("./firebase-config-F6COE3NY.js");
+    const app = initializeApp2(FIREBASE_CONFIG2);
+    const functions = getFunctions(app, "us-central1");
+    const submitFn = httpsCallable(functions, "submitFeedback");
+    await submitFn({ message });
+    console.log("  Sent! Thanks for the feedback.\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`  Failed to submit: ${msg}
+`);
+    process.exit(1);
+  }
+}
+
+// src/commands/missile-calc.ts
+import { calculateMissileCastTime, GCD_DURATION, TICKS_PER_SECOND, calculateMissileRadius } from "@vibemancer/core";
+function runMissileCalc(options) {
+  const config = {
+    damage: options.damage,
+    speed: options.speed,
+    duration: options.duration,
+    turnRate: options.turnRate
+  };
+  const castTimeSec = calculateMissileCastTime(config);
+  const castFrames = Math.max(1, Math.round(castTimeSec * TICKS_PER_SECOND));
+  const gcdSec = GCD_DURATION / TICKS_PER_SECOND;
+  const totalCycleSec = castTimeSec + gcdSec;
+  const dps = config.damage / totalCycleSec;
+  const range = config.speed * config.duration;
+  const radius = calculateMissileRadius(config.damage);
+  console.log(`
+  Missile Calculator
+  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  Config:     damage=${config.damage}  speed=${config.speed}  duration=${config.duration}  turnRate=${config.turnRate}
+  Cast time:  ${castTimeSec.toFixed(3)}s  (${castFrames} frames)
+  GCD:        ${gcdSec}s  (${GCD_DURATION} frames)
+  Full cycle: ${totalCycleSec.toFixed(3)}s  (cast + GCD)
+  Eff. DPS:   ${dps.toFixed(2)} HP/s
+  Range:      ${range} units  (speed \xD7 duration)
+  Hitbox:     ${radius.toFixed(2)} radius
+`);
+}
+
 // src/cli.ts
 var args = process.argv.slice(2);
 var command = args[0];
@@ -1128,6 +1196,8 @@ Commands:
   build        Compile bot to a standalone bundle
   upload       Upload bot to VibeMancer for online competition
   pull         Download latest source code from VibeMancer
+  feedback     Submit a bug report or suggestion
+  missile-calc Calculate missile cast time and DPS for a config
 
 Common options:
   --bot <path>   Path to bot source file (default: auto-discover)
@@ -1136,11 +1206,12 @@ Dev options:
   --port <n>     Server port (default: 4242)
 
 Fight options:
-  --opponent <name>   Fight a single opponent instead of all bots
+  --opponent <name>   Fight a single opponent: a built-in name OR another
+                      user's uploaded bot as handle/botname
   --seed <n>          Random seed
 
 Trace options:
-  --opponent <name>   Opponent bot name (required)
+  --opponent <name>   Opponent: a built-in name OR handle/botname (required)
   --seed <n>          Random seed (default: 1)
   --distance <n>      Spawn distance (default: 600)
 
@@ -1163,6 +1234,8 @@ Examples:
   vibemancer tournament Battlemage Warmage Archmage
   vibemancer optimize
   vibemancer build --opponent Battlemage
+  vibemancer feedback "missiles go through walls sometimes"
+  vibemancer missile-calc --damage 15 --speed 7 --duration 200 --turnRate 3
 `);
 }
 async function main() {
@@ -1192,7 +1265,14 @@ async function main() {
     case "trace": {
       const opponent = parseFlag("--opponent");
       if (!opponent) {
-        console.error("Error: --opponent is required for trace command.");
+        const { getBuiltinBotNames: getBuiltinBotNames2 } = await import("./opponent-resolver-U2UK2QEJ.js");
+        const names = getBuiltinBotNames2();
+        const list = names.map((n) => `  --opponent ${n}`).join("\n");
+        console.error("Error: --opponent is required for trace.\n");
+        console.error(`Available opponents:
+
+${list}
+`);
         console.error("Usage: vibemancer trace --opponent Battlemage");
         process.exit(1);
       }
@@ -1254,6 +1334,20 @@ async function main() {
       await runPull({ bot });
       break;
     }
+    case "feedback": {
+      const message = args.slice(1).join(" ");
+      await runFeedback({ message });
+      break;
+    }
+    case "missile-calc": {
+      runMissileCalc({
+        damage: parseIntFlag("--damage", 15),
+        speed: parseIntFlag("--speed", 7),
+        duration: parseIntFlag("--duration", 200),
+        turnRate: parseIntFlag("--turnRate", 0)
+      });
+      break;
+    }
     default:
       console.error(`Unknown command: ${command}`);
       printHelp();