dankgrinder 5.16.0 → 5.20.0

package/lib/commands/farmVision.js

@@ -0,0 +1,437 @@
+/**
+ * Farm Vision — image-based 3x3 farm grid analysis.
+ *
+ * Similar to fishVision, this computes per-cell features and classifies each
+ * tile with score + confidence.
+ *
+ * States:
+ * - tilled   : mostly brown soil
+ * - wet      : blue/dark wet soil signature
+ * - planted  : strong green crop signature
+ * - unknown  : low-confidence fallback
+ */
+
+const sharp = require('sharp');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+function downloadImage(url) {
+  return new Promise((resolve, reject) => {
+    const proto = url.startsWith('https') ? https : http;
+    const req = proto.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return downloadImage(res.headers.location).then(resolve, reject);
+      }
+      const chunks = [];
+      res.on('data', c => chunks.push(c));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    });
+    req.on('error', reject);
+    req.setTimeout(12000, () => { req.destroy(); reject(new Error('farm image download timeout')); });
+  });
+}
+
+function extractImageUrlFromComponents(components) {
+  for (const item of components || []) {
+    if (!item) continue;
+    const direct = item?.media?.url || item?.media?.proxy_url || item?.media?.proxyURL;
+    if (direct) return direct;
+
+    const allItems = [
+      ...(Array.isArray(item?.items) ? item.items : []),
+      ...(Array.isArray(item?.data?.items) ? item.data.items : []),
+    ];
+    for (const it of allItems) {
+      const u = it?.media?.url || it?.media?.proxy_url || it?.media?.proxyURL || it?.url || null;
+      if (u) return u;
+    }
+
+    if (item.components) {
+      const nested = extractImageUrlFromComponents(item.components);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function extractFarmImageUrl(msg) {
+  const attachmentUrl = (() => {
+    const a = msg?.attachments;
+    if (!a) return null;
+    if (Array.isArray(a) && a[0]) return a[0].url || a[0].proxyURL || null;
+    if (typeof a.values === 'function') {
+      const first = a.values().next()?.value;
+      return first?.url || first?.proxyURL || null;
+    }
+    return null;
+  })();
+  if (attachmentUrl) return attachmentUrl;
+
+  const embedUrl = msg?.embeds?.[0]?.image?.url || msg?.embeds?.[0]?.thumbnail?.url;
+  if (embedUrl) return embedUrl;
+
+  const cv2Url = extractImageUrlFromComponents(msg?._cv2);
+  if (cv2Url) return cv2Url;
+
+  return extractImageUrlFromComponents(msg?.components);
+}
+
+function colorStatsForPixel(r, g, b) {
+  const sum = r + g + b;
+  const brightness = sum / 3;
+  const greenStrong = g > r * 1.12 && g > b * 1.1;
+  const blueStrong = b > r * 1.08 && b > g * 1.02;
+  const brownish = r > g * 1.03 && g > b * 1.03 && r > 45 && g > 28 && b < 95;
+  const dark = brightness < 56;
+  const whiteish = brightness > 210 && Math.abs(r - g) < 20 && Math.abs(g - b) < 20;
+  return { brightness, greenStrong, blueStrong, brownish, dark, whiteish };
+}
+
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+
+function classifyCell(features) {
+  const { greenPct, bluePct, brownPct, darkPct, avgBrightness } = features;
+
+  // Score bands tuned for Dank farm palette.
+  const scorePlanted =
+    (greenPct * 1.9) +
+    (clamp01((120 - avgBrightness) / 120) * 0.2) -
+    (bluePct * 0.4);
+
+  const scoreWet =
+    (bluePct * 1.7) +
+    (darkPct * 0.7) +
+    (clamp01((105 - avgBrightness) / 105) * 0.15) -
+    (greenPct * 0.35);
+
+  const scoreTilled =
+    (brownPct * 1.9) +
+    (clamp01((125 - avgBrightness) / 125) * 0.1) -
+    (greenPct * 0.25) -
+    (bluePct * 0.2);
+
+  const scored = [
+    ['planted', scorePlanted],
+    ['wet', scoreWet],
+    ['tilled', scoreTilled],
+  ].sort((a, b) => b[1] - a[1]);
+
+  const [bestState, bestScore] = scored[0];
+  const secondScore = scored[1][1];
+  const margin = bestScore - secondScore;
+
+  // Confidence from score margin + minimum signal level.
+  const signal = Math.max(greenPct, bluePct, brownPct);
+  const confidence = clamp01((margin * 2.1) + (signal * 0.6));
+
+  // Low-signal cells become unknown.
+  if (signal < 0.085 || confidence < 0.20) {
+    return { state: 'unknown', confidence: +confidence.toFixed(3), scores: { planted: +scorePlanted.toFixed(3), wet: +scoreWet.toFixed(3), tilled: +scoreTilled.toFixed(3) } };
+  }
+
+  return {
+    state: bestState,
+    confidence: +confidence.toFixed(3),
+    scores: {
+      planted: +scorePlanted.toFixed(3),
+      wet: +scoreWet.toFixed(3),
+      tilled: +scoreTilled.toFixed(3),
+    },
+  };
+}
+
+async function analyzeFarmGrid(imgBuffer, cols = 3, rows = 3) {
+  const { data, info } = await sharp(imgBuffer).raw().toBuffer({ resolveWithObject: true });
+  const { width, height, channels } = info;
+  const cellW = Math.floor(width / cols);
+  const cellH = Math.floor(height / rows);
+
+  const cells = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const sx = col * cellW;
+      const sy = row * cellH;
+      const ex = Math.min(sx + cellW, width);
+      const ey = Math.min(sy + cellH, height);
+
+  // Sample center region only (ignore grass borders around each tile).
+  const padX = Math.floor((ex - sx) * 0.18);
+  const padY = Math.floor((ey - sy) * 0.18);
+  const csx = sx + padX;
+  const csy = sy + padY;
+  const cex = ex - padX;
+  const cey = ey - padY;
+
+      let total = 0;
+      let greenPx = 0;
+      let bluePx = 0;
+      let brownPx = 0;
+      let darkPx = 0;
+      let whitePx = 0;
+      let brightSum = 0;
+
+      for (let y = csy; y < cey; y++) {
+        for (let x = csx; x < cex; x++) {
+          const idx = (y * width + x) * channels;
+          const r = data[idx];
+          const g = data[idx + 1];
+          const b = data[idx + 2];
+          const s = colorStatsForPixel(r, g, b);
+          total++;
+          brightSum += s.brightness;
+          if (s.greenStrong) greenPx++;
+          if (s.blueStrong) bluePx++;
+          if (s.brownish) brownPx++;
+          if (s.dark) darkPx++;
+          if (s.whiteish) whitePx++;
+        }
+      }
+
+      const greenPct = greenPx / total;
+      const bluePct = bluePx / total;
+      const brownPct = brownPx / total;
+      const darkPct = darkPx / total;
+      const whitePct = whitePx / total;
+      const avgBrightness = brightSum / total;
+
+      const classified = classifyCell({ greenPct, bluePct, brownPct, darkPct, avgBrightness, whitePct });
+
+      cells.push({
+        row,
+        col,
+        state: classified.state,
+        confidence: classified.confidence,
+        scores: classified.scores,
+        greenPct: +greenPct.toFixed(3),
+        bluePct: +bluePct.toFixed(3),
+        brownPct: +brownPct.toFixed(3),
+        darkPct: +darkPct.toFixed(3),
+        whitePct: +whitePct.toFixed(3),
+        avgBrightness: +avgBrightness.toFixed(1),
+      });
+    }
+  }
+
+  const counts = { tilled: 0, wet: 0, planted: 0, unknown: 0 };
+  for (const c of cells) counts[c.state] = (counts[c.state] || 0) + 1;
+
+  const avgConfidence = cells.length > 0
+    ? +(cells.reduce((s, c) => s + (c.confidence || 0), 0) / cells.length).toFixed(3)
+    : 0;
+
+  return { width, height, rows, cols, cells, counts, avgConfidence };
+}
+
+function gridToString(analysis) {
+  const icon = { tilled: 'T', wet: 'W', planted: 'P', unknown: '?' };
+  const rows = [];
+  for (let r = 0; r < (analysis?.rows || 0); r++) {
+    const line = [];
+    for (let c = 0; c < (analysis?.cols || 0); c++) {
+      const cell = (analysis?.cells || []).find(x => x.row === r && x.col === c);
+      line.push(icon[cell?.state || 'unknown']);
+    }
+    rows.push(line.join(' '));
+  }
+  return rows.join(' | ');
+}
+
+function evaluateActionNeed(actionName, analysis) {
+  const c = analysis?.counts || {};
+  const tilled = c.tilled || 0;
+  const wet = c.wet || 0;
+  const planted = c.planted || 0;
+  const unknown = c.unknown || 0;
+  const conf = analysis?.avgConfidence || 0;
+  const slots = 9;
+
+  // Avoid aggressive repeats when confidence is too low.
+  if (conf < 0.22) return false;
+
+  // Conservative rules: only request repeat if we have clear evidence.
+  if (actionName === 'hoe') {
+    return (tilled + wet + planted) < slots && unknown < 6;
+  }
+  if (actionName === 'water') {
+    // If still many plain-tilled (not watered/planted), water likely incomplete.
+    return tilled > 0 && (wet + planted) < slots;
+  }
+  if (actionName === 'plant') {
+    return planted < slots && (tilled + wet) > 0;
+  }
+  if (actionName === 'harvest') {
+    // If many planted remain, harvest may still be pending.
+    return planted > 0;
+  }
+
+  // Fertilizer optional; do not force repeats.
+  return false;
+}
+
+function evaluateActionScores(actionName, analysis) {
+  const c = analysis?.counts || {};
+  const slots = Math.max(1, (analysis?.rows || 3) * (analysis?.cols || 3));
+  const tilled = c.tilled || 0;
+  const wet = c.wet || 0;
+  const planted = c.planted || 0;
+  const unknown = c.unknown || 0;
+  const conf = analysis?.avgConfidence || 0;
+
+  const ratios = {
+    tilled: tilled / slots,
+    wet: wet / slots,
+    planted: planted / slots,
+    unknown: unknown / slots,
+  };
+
+  const clamp = (n) => Math.max(0, Math.min(1, n));
+  const withConf = (base, mult = 0.25) => clamp(base * (0.82 + (conf * mult)));
+
+  let score = 0;
+  let threshold = 0.8;
+  let reason = 'ok';
+
+  if (actionName === 'hoe') {
+    // Hoe is considered good if farm has mostly actionable soil/crops and little unknown noise.
+    const base = (ratios.tilled * 0.9) + (ratios.wet * 0.52) + (ratios.planted * 0.4) - (ratios.unknown * 0.32);
+    score = withConf(base);
+    threshold = 0.68;
+    if (ratios.unknown > 0.45) reason = 'too_many_unknown_cells';
+    else if (ratios.tilled < 0.45 && (ratios.wet + ratios.planted) < 0.35) reason = 'not_enough_tilled_or_progressed_tiles';
+  } else if (actionName === 'water') {
+    // After watering, we want wet/planted dominance and minimal plain-tilled.
+    const base = (ratios.wet * 0.92) + (ratios.planted * 0.34) - (ratios.tilled * 0.48) - (ratios.unknown * 0.22);
+    score = withConf(base);
+    threshold = 0.7;
+    if (ratios.planted >= 0.45) {
+      // If many planted tiles are already visible, watering phase is effectively done.
+      score = Math.max(score, withConf(0.86));
+      reason = 'progressed_to_plant_phase';
+    }
+    if (ratios.wet < 0.45 && ratios.planted < 0.2) reason = 'not_enough_wet_tiles';
+    else if (ratios.tilled > 0.4) reason = 'too_many_dry_tilled_tiles';
+  } else if (actionName === 'plant') {
+    // Plant stage should end with mostly planted tiles.
+    const base = (ratios.planted * 0.96) + (ratios.wet * 0.12) - (ratios.tilled * 0.48) - (ratios.unknown * 0.2);
+    score = withConf(base);
+    threshold = 0.72;
+    if (ratios.planted < 0.6) reason = 'not_enough_planted_tiles';
+  } else if (actionName === 'harvest') {
+    // Harvest should reduce planted tiles; tilled/wet should dominate after collection.
+    const base = ((ratios.tilled + ratios.wet) * 0.86) - (ratios.planted * 0.76) - (ratios.unknown * 0.18);
+    score = withConf(base);
+    threshold = 0.68;
+    if (ratios.planted > 0.34) reason = 'too_many_unharvested_plants';
+  } else {
+    score = withConf(0.7 - (ratios.unknown * 0.2));
+    threshold = 0.7;
+  }
+
+  const matched = conf >= 0.2 && score >= threshold;
+
+  return {
+    action: actionName,
+    matched,
+    score: +score.toFixed(3),
+    threshold: +threshold.toFixed(3),
+    confidence: +conf.toFixed(3),
+    reason,
+    counts: { tilled, wet, planted, unknown, slots },
+    ratios: {
+      tilled: +ratios.tilled.toFixed(3),
+      wet: +ratios.wet.toFixed(3),
+      planted: +ratios.planted.toFixed(3),
+      unknown: +ratios.unknown.toFixed(3),
+    },
+  };
+}
+
+async function dumpFarmVisionDebug({
+  imgBuffer,
+  analysis,
+  actionName = 'unknown',
+  sourceUrl = null,
+}) {
+  const root = path.resolve(__dirname, '../../tmp-cv2-dumps/farm-vision');
+  const stamp = `${Date.now()}-${actionName}`;
+  const dir = path.join(root, stamp);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const sourcePath = path.join(dir, 'source.png');
+  await sharp(imgBuffer).png().toFile(sourcePath);
+
+  const cols = analysis?.cols || 3;
+  const rows = analysis?.rows || 3;
+  const width = analysis?.width || 0;
+  const height = analysis?.height || 0;
+  const cellW = Math.floor(width / cols);
+  const cellH = Math.floor(height / rows);
+
+  const tiles = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const sx = col * cellW;
+      const sy = row * cellH;
+      const ex = Math.min(sx + cellW, width);
+      const ey = Math.min(sy + cellH, height);
+      const w = Math.max(1, ex - sx);
+      const h = Math.max(1, ey - sy);
+
+      const cell = (analysis?.cells || []).find(c => c.row === row && c.col === col) || null;
+      const state = cell?.state || 'unknown';
+      const conf = Number.isFinite(cell?.confidence) ? cell.confidence : 0;
+      const tileName = `tile-r${row + 1}-c${col + 1}-${state}-c${String(conf).replace('.', '_')}.png`;
+      const tilePath = path.join(dir, tileName);
+
+      await sharp(imgBuffer)
+        .extract({ left: sx, top: sy, width: w, height: h })
+        .png()
+        .toFile(tilePath);
+
+      tiles.push({
+        row,
+        col,
+        state,
+        confidence: conf,
+        path: tilePath,
+        bbox: { x: sx, y: sy, w, h },
+        features: cell || null,
+      });
+    }
+  }
+
+  const manifestPath = path.join(dir, 'manifest.json');
+  const manifest = {
+    createdAt: new Date().toISOString(),
+    actionName,
+    sourceUrl,
+    image: { width, height, rows, cols },
+    counts: analysis?.counts || null,
+    avgConfidence: analysis?.avgConfidence ?? null,
+    sourcePath,
+    tiles,
+  };
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+  return {
+    dir,
+    sourcePath,
+    manifestPath,
+    tileCount: tiles.length,
+  };
+}
+
+module.exports = {
+  downloadImage,
+  extractFarmImageUrl,
+  analyzeFarmGrid,
+  gridToString,
+  evaluateActionNeed,
+  evaluateActionScores,
+  dumpFarmVisionDebug,
+};

package/lib/commands/index.js

@@ -8,6 +8,7 @@ const { runBeg } = require('./beg');
 const { runSearch, SAFE_SEARCH_LOCATIONS } = require('./search');
 const { runCrime, SAFE_CRIME_OPTIONS } = require('./crime');
 const { runHighLow } = require('./highlow');
+const { runFarm } = require('./farm');
 const { runHunt } = require('./hunt');
 const { runDig } = require('./dig');
 const { runFish, sellAllFish } = require('./fish');
@@ -32,6 +33,7 @@ module.exports = {
   runSearch,
   runCrime,
   runHighLow,
+  runFarm,
   runHunt,
   runDig,
   runFish,

package/lib/commands/inventory.js

@@ -218,10 +218,13 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   const allItems = [];
   let { page, total } = parsePageInfo(response);
   LOG.info(`[inv] Page ${page}/${total}`);
+  const visitedPages = new Set([page]);
 
   allItems.push(...parseInventoryPage(response));
 
-  while (page < total) {
+  let guard = 0;
+  while (page < total && guard < Math.max(20, total + 6)) {
+    guard++;
     const buttons = getAllButtons(response);
     const enabled = buttons.filter(b => !b.disabled);
 
@@ -231,13 +234,43 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
       return m ? parseInt(m[1], 10) : null;
     };
 
-    let nextBtn = enabled.find((b) => {
-      const id = String(b.customId || '');
-      if (!/paginator-inventory-list/i.test(id)) return false;
-      if (!/setpage/i.test(id)) return false;
-      return parseTargetPage(id) === page;
+    const classifyButton = (b) => {
+      const id = String(b.customId || '').toLowerCase();
+      const label = String(b.label || '').toLowerCase();
+      const emoji = String(b.emoji?.name || '').toLowerCase();
+      return { id, label, emoji };
+    };
+
+    const directNext = enabled.find((b) => {
+      const { id, label, emoji } = classifyButton(b);
+      if (id.includes('last') || label === '⏭' || emoji.includes('doubleright')) return false;
+      return id.includes('next')
+        || label.includes('next')
+        || label === '▶'
+        || label === '→'
+        || emoji.includes('arrowright');
     });
 
+    let nextBtn = directNext || null;
+
+    if (!nextBtn) {
+      const paginatorCandidates = enabled
+        .map((b) => ({ b, id: String(b.customId || ''), target: parseTargetPage(b.customId || '') }))
+        .filter((x) => /paginator-inventory-list/i.test(x.id) && /setpage/i.test(x.id) && Number.isInteger(x.target));
+
+      // Prefer the smallest target greater than current page.
+      // Fallback to target===current page for legacy/offset paginator ids.
+      const gtCurrent = paginatorCandidates
+        .filter(x => x.target > page)
+        .sort((a, b) => a.target - b.target);
+      if (gtCurrent.length > 0) {
+        nextBtn = gtCurrent[0].b;
+      } else {
+        const eqCurrent = paginatorCandidates.find(x => x.target === page);
+        if (eqCurrent) nextBtn = eqCurrent.b;
+      }
+    }
+
     if (!nextBtn) {
       nextBtn = enabled.find((b) => {
         const id = (b.customId || '').toLowerCase();
@@ -256,35 +289,13 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
 
     await humanDelay(200, 400);
 
-    // Set up messageUpdate listener BEFORE clicking so we don't miss the update
-    const msgId = response.id;
-    const updatePromise = new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        client.removeListener('messageUpdate', handler);
-        resolve(null);
-      }, 10000);
-      const handler = (_, m) => {
-        if (m.id === msgId) {
-          clearTimeout(timeout);
-          client.removeListener('messageUpdate', handler);
-          resolve(m);
-        }
-      };
-      client.on('messageUpdate', handler);
-    });
-
     try {
-      await safeClickButton(response, nextBtn);
+      const clicked = await safeClickButton(response, nextBtn);
+      if (clicked) response = clicked;
     } catch {
       break;
     }
 
-    // Wait for actual message update from Discord (page content change)
-    const updated = await updatePromise;
-    if (updated) {
-      response = updated;
-    }
-
     // Force-refetch CV2 with retries until page actually changes
     delete response._cv2;
     delete response._cv2text;
@@ -293,12 +304,18 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
     let pageChanged = false;
     for (let attempt = 0; attempt < 4; attempt++) {
       await sleep(attempt === 0 ? 600 : 1200);
+      try {
+        const fresh = await channel.messages.fetch(response.id);
+        if (fresh) response = fresh;
+      } catch {}
       if (isCV2(response)) await ensureCV2(response, true);
       const pageInfo = parsePageInfo(response);
-      if (pageInfo.page > page) {
+      if (pageInfo.page > page && !visitedPages.has(pageInfo.page)) {
         page = pageInfo.page;
         total = pageInfo.total;
+        visitedPages.add(page);
         pageChanged = true;
+        LOG.info(`[inv] Page ${page}/${total}`);
         break;
       }
       // Clear CV2 cache again for next retry
@@ -323,7 +340,7 @@ async function runInventory({ channel, waitForDankMemer, client, accountId, redi
   }
 
   const items = Object.values(itemMap);
-  LOG.success(`[inv] Found ${items.length} unique items across ${total} pages`);
+  LOG.success(`[inv] Found ${items.length} unique items across ${visitedPages.size}/${total} pages`);
 
   const { totalValue, totalMarket } = await enrichItems(items);
   LOG.info(`[inv] Net value: ${c.bold}${c.green}⏣ ${totalValue.toLocaleString()}${c.reset}  Market: ${c.bold}⏣ ${totalMarket.toLocaleString()}${c.reset}`);