dankgrinder 3.0.0 → 4.1.0

package/lib/commands/trivia.js

@@ -0,0 +1,146 @@
+/**
+ * Trivia command handler.
+ * Send "pls trivia", look up answer in trivia DB, click correct answer.
+ * If no match found, pick random (25% chance).
+ * 
+ * Trivia DB: Redis-backed persistent store with in-memory fallback.
+ * Key format: "trivia:<first 80 chars of question, lowercased, trimmed>"
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+const triviaDB = {};
+
+function makeQuestionKey(question) {
+  return question.toLowerCase().trim().substring(0, 80);
+}
+
+async function lookupAnswer(question, buttons, redis) {
+  const qKey = makeQuestionKey(question);
+  let answer = null;
+
+  if (redis) {
+    try {
+      answer = await redis.get('trivia:' + qKey);
+    } catch (e) {
+      LOG.debug(`[trivia] Redis lookup failed: ${e.message}`);
+    }
+  }
+
+  if (!answer) {
+    answer = triviaDB[qKey];
+  }
+
+  if (answer) {
+    const btn = buttons.find(b => (b.label || '').toLowerCase() === answer.toLowerCase());
+    if (btn && !btn.disabled) {
+      LOG.debug(`[trivia] DB hit: "${qKey.substring(0, 40)}..." → "${answer}"`);
+      return btn;
+    }
+  }
+
+  for (const [storedKey, storedAnswer] of Object.entries(triviaDB)) {
+    if (qKey.includes(storedKey) || storedKey.includes(qKey)) {
+      const btn = buttons.find(b => (b.label || '').toLowerCase() === storedAnswer.toLowerCase());
+      if (btn && !btn.disabled) {
+        LOG.debug(`[trivia] DB partial hit: "${storedKey.substring(0, 40)}..." → "${storedAnswer}"`);
+        return btn;
+      }
+    }
+  }
+
+  return null;
+}
+
+async function learnFromResult(question, correctAnswer, redis) {
+  if (!question || !correctAnswer) return;
+  const key = makeQuestionKey(question);
+
+  triviaDB[key] = correctAnswer;
+
+  if (redis) {
+    try {
+      await redis.set('trivia:' + key, correctAnswer);
+    } catch (e) {
+      LOG.debug(`[trivia] Redis write failed: ${e.message}`);
+    }
+  }
+
+  LOG.debug(`[trivia] Learned: "${key.substring(0, 40)}..." → "${correctAnswer}"`);
+}
+
+async function runTrivia({ channel, waitForDankMemer, redis }) {
+  LOG.cmd(`${c.white}${c.bold}pls trivia${c.reset}`);
+
+  await channel.send('pls trivia');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[trivia] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[trivia] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'trivia');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    return { result: text.substring(0, 60), coins: 0 };
+  }
+
+  const clickable = buttons.filter(b => !b.disabled);
+  if (clickable.length === 0) return { result: 'no clickable buttons', coins: 0 };
+
+  const question = (response.embeds?.[0]?.description || '').replace(/\*\*/g, '').replace(/\*.*?\*/g, '').trim();
+
+  let btn = await lookupAnswer(question, clickable, redis || null);
+  const fromDB = !!btn;
+  if (!btn) {
+    btn = clickable[Math.floor(Math.random() * clickable.length)];
+  }
+  LOG.info(`[trivia] ${fromDB ? '(DB)' : '(random)'} Picking: "${btn.label}"`);
+
+  await humanDelay();
+  try {
+    const followUp = await safeClickButton(response, btn);
+    if (followUp) {
+      logMsg(followUp, 'trivia-result');
+      const text = getFullText(followUp);
+      const coins = parseCoins(text);
+
+      const lower = text.toLowerCase();
+      const correctMatch = text.match(/correct answer was \*\*(.+?)\*\*/i);
+      if (correctMatch) {
+        await learnFromResult(question, correctMatch[1], redis || null);
+      } else if (lower.includes('correct') || lower.includes('nice') || lower.includes('right')) {
+        await learnFromResult(question, btn.label, redis || null);
+      }
+
+      if (coins > 0) {
+        LOG.coin(`[trivia] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+        return { result: `trivia → ${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };
+      }
+      if (lower.includes('correct answer was') || lower.includes('nitwit') || lower.includes('wrong') || lower.includes('incorrect')) {
+        return { result: `trivia → ${btn.label} → ${c.red}wrong${c.reset}`, coins: 0 };
+      }
+      if (lower.includes('correct') || lower.includes('nice') || lower.includes('right')) {
+        return { result: `trivia → ${btn.label} → ${c.green}correct${c.reset}`, coins: 0 };
+      }
+      return { result: `trivia → ${btn.label}`, coins: 0 };
+    }
+  } catch (e) { LOG.error(`[trivia] Click error: ${e.message}`); }
+
+  return { result: 'trivia done', coins: 0 };
+}
+
+module.exports = { runTrivia, triviaDB };

package/lib/commands/utils.js

@@ -0,0 +1,287 @@
+/**
+ * Shared utilities for all Dank Memer command handlers.
+ * Every command file imports from here instead of duplicating helpers.
+ */
+
+const DANK_MEMER_ID = '270904126974590976';
+
+// ── Terminal Colors ──────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', italic: '\x1b[3m',
+  green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', cyan: '\x1b[36m',
+  magenta: '\x1b[35m', white: '\x1b[37m', blue: '\x1b[34m',
+};
+
+// ── Logging ──────────────────────────────────────────────────
+function log(label, msg) {
+  const time = new Date().toLocaleTimeString('en-US', { hour12: true, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+  console.log(`  ${c.dim}${time}${c.reset}  ${label}  ${msg}`);
+}
+
+const LOG = {
+  info:    (msg) => log(`${c.cyan}│${c.reset}`, msg),
+  success: (msg) => log(`${c.green}✓${c.reset}`, msg),
+  error:   (msg) => log(`${c.red}✗${c.reset}`, msg),
+  warn:    (msg) => log(`${c.yellow}!${c.reset}`, msg),
+  cmd:     (msg) => log(`${c.magenta}▸${c.reset}`, msg),
+  coin:    (msg) => log(`${c.yellow}$${c.reset}`, msg),
+  buy:     (msg) => log(`${c.blue}♦${c.reset}`, msg),
+  debug:   (msg) => log(`${c.dim}⊙${c.reset}`, msg),
+};
+
+// ── Sleep ────────────────────────────────────────────────────
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+function humanDelay(min = 100, max = 350) {
+  return new Promise(r => setTimeout(r, min + Math.random() * (max - min)));
+}
+
+// ── Message Parsing ──────────────────────────────────────────
+function getFullText(msg) {
+  if (!msg) return '';
+  let text = msg.content || '';
+  for (const embed of msg.embeds || []) {
+    if (embed.title) text += ' ' + embed.title;
+    if (embed.description) text += ' ' + embed.description;
+    for (const f of embed.fields || []) text += ' ' + (f.name || '') + ' ' + (f.value || '');
+    if (embed.footer?.text) text += ' ' + embed.footer.text;
+  }
+  // CV2 components text — recursively extract from containers, sections, text displays
+  function extractText(components) {
+    for (const comp of components || []) {
+      if (comp.content) text += ' ' + comp.content;
+      if (comp.components) extractText(comp.components);
+    }
+  }
+  extractText(msg.components);
+  return text;
+}
+
+function parseCoins(text) {
+  if (!text) return 0;
+  // Match ⏣ prefixed coins
+  const matches = text.match(/⏣\s*([\d,]+)/g);
+  if (!matches) return 0;
+  let best = 0;
+  for (const m of matches) {
+    const numStr = m.replace(/[^\d]/g, '');
+    if (numStr) {
+      const val = parseInt(numStr);
+      if (val > 0 && val < 10000000) best = Math.max(best, val);
+    }
+  }
+  return best;
+}
+
+/**
+ * Parse wallet balance from a balance response message.
+ * Handles both embed-based and CV2 TEXT_DISPLAY component formats.
+ * CV2 format: "<:Coin:1105833876032606350> 243,322\n<:Bank:...> 20,000 / 20,000"
+ */
+function parseBalance(msg) {
+  if (!msg) return 0;
+  const text = getFullText(msg);
+
+  // Try standard embed wallet pattern
+  const walletMatch = text.match(/wallet[:\s]*[⏣💰]?\s*([\d,]+)/i);
+  if (walletMatch) return parseInt(walletMatch[1].replace(/,/g, ''));
+
+  // CV2 pattern: <:Coin:ID> NUMBER (first number after Coin emoji = wallet)
+  const coinEmojiMatch = text.match(/<:Coin:\d+>\s*([\d,]+)/);
+  if (coinEmojiMatch) return parseInt(coinEmojiMatch[1].replace(/,/g, ''));
+
+  // Fallback: ⏣ prefixed
+  const coins = parseCoins(text);
+  if (coins > 0) return coins;
+
+  // Last resort: first large number not in "X / Y" bank pattern
+  const cleaned = text.replace(/[\d,]+\s*\/\s*[\d,]+/g, '');
+  const numMatch = cleaned.match(/([\d,]{2,})/);
+  if (numMatch) return parseInt(numMatch[1].replace(/,/g, ''));
+
+  return 0;
+}
+
+// ── Component Helpers ────────────────────────────────────────
+// Recursively collect components from CV2 containers, sections, action rows,
+// and SECTION accessory buttons (e.g. "Fish Again" in fishing result screen)
+function flattenComponents(components) {
+  const flat = [];
+  for (const item of components || []) {
+    if (item.type === 2 || item.type === 'BUTTON' ||
+        item.type === 3 || item.type === 'SELECT_MENU' || item.type === 'STRING_SELECT') {
+      flat.push(item);
+    }
+    // Recurse into containers, action rows, sections, etc.
+    if (item.components) flat.push(...flattenComponents(item.components));
+    // SECTION accessory can be a button (e.g. "Fish Again" in Dank Memer fishing)
+    if (item.data?.accessory) {
+      const acc = item.data.accessory;
+      if (acc.type === 2 || acc.type === 'BUTTON') {
+        // Build a proper button-like object from the raw accessory data
+        flat.push({
+          type: 'BUTTON',
+          label: acc.label,
+          customId: acc.custom_id,
+          style: acc.style,
+          disabled: acc.disabled || false,
+          emoji: acc.emoji,
+          data: acc,
+          // Keep reference for safeClickButton
+          _accessoryOf: item,
+        });
+      }
+    }
+  }
+  return flat;
+}
+
+function getAllButtons(msg) {
+  const all = flattenComponents(msg.components);
+  return all.filter(c => c.type === 2 || c.type === 'BUTTON');
+}
+
+function getAllSelectMenus(msg) {
+  const all = flattenComponents(msg.components);
+  return all.filter(c => c.type === 3 || c.type === 'SELECT_MENU' || c.type === 'STRING_SELECT');
+}
+
+function findButton(msg, labelPart) {
+  return getAllButtons(msg).find(b => b.label && b.label.toLowerCase().includes(labelPart.toLowerCase())) || null;
+}
+
+function findSelectMenuOption(msg, label) {
+  const menus = getAllSelectMenus(msg);
+  for (const comp of menus) {
+    const opt = (comp.options || []).find(o => o.label?.toLowerCase().includes(label.toLowerCase()));
+    if (opt) return { menuCustomId: comp.customId, option: opt, component: comp };
+  }
+  return null;
+}
+
+// Safe button click — tries .click() first, falls back to msg.clickButton()
+async function safeClickButton(msg, button) {
+  if (typeof button.click === 'function') {
+    return button.click();
+  }
+  if (button.customId && typeof msg.clickButton === 'function') {
+    return msg.clickButton(button.customId);
+  }
+  throw new Error('No click method available on button');
+}
+
+// ── Hold Tight Detection ─────────────────────────────────────
+function isHoldTight(msg) {
+  if (!msg) return false;
+  const text = getFullText(msg).toLowerCase();
+  return text.includes('hold tight') || text.includes('unable to interact') || text.includes('ongoing command');
+}
+
+/**
+ * Parse Hold Tight reason from message.
+ * Format: "Reason: /postmemes" or "Reason: /adventure"
+ * Returns the command name (e.g. 'postmemes', 'adventure') or null.
+ */
+function getHoldTightReason(msg) {
+  if (!msg) return null;
+  const text = getFullText(msg);
+  const match = text.match(/Reason:\s*\/(\w+)/i);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// ── Debug Logger ─────────────────────────────────────────────
+function logMsg(msg, label) {
+  if (!msg) { LOG.debug(`[${label}] No message`); return; }
+  // Content
+  if (msg.content) LOG.debug(`[${label}] content: "${msg.content.substring(0, 200).replace(/\n/g, ' ')}"`);
+  // Embeds
+  for (const e of msg.embeds || []) {
+    if (e.title) LOG.debug(`[${label}] title: "${e.title}"`);
+    if (e.description) LOG.debug(`[${label}] desc: "${e.description.substring(0, 200).replace(/\n/g, ' ')}"`);
+    for (const f of e.fields || []) LOG.debug(`[${label}] field: "${f.name}" = "${(f.value || '').substring(0, 150)}"`);
+    if (e.footer?.text) LOG.debug(`[${label}] footer: "${e.footer.text}"`);
+    if (e.image?.url) LOG.debug(`[${label}] image: ${e.image.url.substring(0, 80)}`);
+  }
+  // Components (buttons, selects, CV2 text)
+  for (const row of msg.components || []) {
+    if (row.type === 'TEXT_DISPLAY' && row.content)
+      LOG.debug(`[${label}] cv2-text: "${row.content.substring(0, 200).replace(/\n/g, ' ')}"`);
+    if (row.type === 'CONTAINER' || row.type === 'SECTION') {
+      for (const comp of row.components || []) {
+        if (comp.type === 'TEXT_DISPLAY' && comp.content)
+          LOG.debug(`[${label}] cv2-section: "${comp.content.substring(0, 200).replace(/\n/g, ' ')}"`);
+        if (comp.components) {
+          for (const sub of comp.components) {
+            if (sub.type === 'TEXT_DISPLAY' && sub.content)
+              LOG.debug(`[${label}] cv2-nested: "${sub.content.substring(0, 200).replace(/\n/g, ' ')}"`);
+          }
+        }
+      }
+    }
+    for (const comp of row.components || []) {
+      if (comp.type === 'BUTTON' || comp.type === 2)
+        LOG.debug(`[${label}] btn: "${comp.label}" emoji=${comp.emoji?.name || '-'} disabled=${comp.disabled} style=${comp.style} id=${(comp.customId || '').substring(0, 40)}`);
+      if (comp.type === 'STRING_SELECT' || comp.type === 3)
+        LOG.debug(`[${label}] select: ${comp.customId} [${comp.options?.map(o => `${o.label}${o.default ? '*' : ''}`).join(', ')}]`);
+    }
+  }
+}
+
+// ── Dump full message raw (for debugging) ────────────────────
+function dumpMessage(msg, label) {
+  console.log(`\n═══ [${label}] ═══`);
+  console.log(`  author: ${msg.author?.tag} (${msg.author?.id})`);
+  console.log(`  content: "${msg.content || ''}"`);
+  console.log(`  embeds (${msg.embeds?.length || 0}):`);
+  for (const e of msg.embeds || []) {
+    console.log(JSON.stringify({
+      title: e.title, description: e.description,
+      fields: e.fields?.map(f => ({ name: f.name, value: f.value })),
+      footer: e.footer?.text, color: e.color,
+    }, null, 2));
+  }
+  console.log(`  components (${msg.components?.length || 0}):`);
+  for (const row of msg.components || []) {
+    for (const comp of row.components || []) {
+      console.log(`    type=${comp.type} label="${comp.label}" customId="${comp.customId}" disabled=${comp.disabled} style=${comp.style}`);
+      if (comp.options) console.log(`    options: ${JSON.stringify(comp.options.map(o => ({ label: o.label, value: o.value, default: o.default })))}`);
+    }
+  }
+}
+
+// ── Item Detection ───────────────────────────────────────────
+function needsItem(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("don't have a shovel") || (lower.includes('need') && lower.includes('shovel')) || lower.includes('you need a shovel'))
+    return 'shovel';
+  if (lower.includes("don't have a fishing") || lower.includes('need a fishing') || lower.includes('you need a fishing pole'))
+    return 'fishing pole';
+  if (lower.includes("don't have a hunting rifle") || lower.includes('need a hunting rifle') || lower.includes('you need a rifle'))
+    return 'hunting rifle';
+  if (lower.includes("don't have") && lower.includes('ticket'))
+    return 'adventure ticket';
+  if (lower.includes('need') && lower.includes('ticket'))
+    return 'adventure ticket';
+  return null;
+}
+
+module.exports = {
+  DANK_MEMER_ID,
+  c,
+  LOG,
+  sleep,
+  humanDelay,
+  getFullText,
+  parseCoins,
+  parseBalance,
+  getAllButtons,
+  getAllSelectMenus,
+  findButton,
+  findSelectMenuOption,
+  safeClickButton,
+  isHoldTight,
+  getHoldTightReason,
+  logMsg,
+  dumpMessage,
+  needsItem,
+};