dankgrinder 6.27.0 → 6.34.0

package/lib/commands/farm.js

@@ -84,22 +84,8 @@ function parseFarmGrowReadySec(text) {
   const clean = String(stripAnsi(text || ''));
   const lower = clean.toLowerCase();
 
-  // TEMP DEBUG: log what we're parsing
-  const hasHarvestReady = /ready to harvest|harvest ready|can be harvested/i.test(lower);
-  const hasWilt = /\bwilt/i.test(lower);
-  if (hasHarvestReady || hasWilt) {
-    // eslint-disable-next-line no-console
-    console.log('[parseFarmGrowReadySec DEBUG] hasHarvestReady=' + hasHarvestReady + ' hasWilt=' + hasWilt + ' clean=' + clean.slice(0, 300));
-  }
-
   // If crops are already harvestable, don't queue waiting.
-  if (/ready to harvest|harvest ready|can be harvested|wilt/i.test(lower)) {
-    // eslint-disable-next-line no-console
-    console.log('[parseFarmGrowReadySec] MATCH — returning 0 (lower=' + lower.slice(0, 200) + ')');
-    return 0;
-  }
-  // eslint-disable-next-line no-console
-  console.log('[parseFarmGrowReadySec] NO MATCH — checking timestamp parse (lower=' + lower.slice(0, 200) + ')');
+  if (/ready to harvest|harvest ready|can be harvested|wilts?/i.test(lower)) return 0;
 
   // If the farm is empty / shows plantable / needs tilling, no grow queue needed.
   // This handles the post-harvest state where Dank Memer shows
@@ -164,6 +150,11 @@ const FARM_BUY_ALIASES = Object.freeze({
 
 const FARM_TOTAL_SLOTS = 9;
 const FARM_PHASE_ORDER = ['hoe', 'water', 'plant', 'harvest'];
+// Seed preference: random among potato/beans group, else carrot, else highest-qty fallback
+const SEED_PRIORITY_GROUPS = [
+  ['potato', 'beans', 'bean'],  // random pick when available
+  ['carrot'],                   // fallback
+];
 
 function parseMissingFarmItem(text) {
   const lower = String(stripAnsi(text || '')).toLowerCase();
@@ -556,12 +547,22 @@ function chooseSeedOption(menu) {
   const withQty = options.map(o => {
     const label = String(o.label || '');
     const m = label.match(/\((\d{1,5})\)/);
-    return { option: o, qty: m ? parseInt(m[1], 10) : 0, isDefault: !!o.default };
+    return { option: o, qty: m ? parseInt(m[1], 10) : 0, label };
   });
 
-  const defaultOpt = withQty.find(x => x.isDefault && x.qty > 0);
-  if (defaultOpt) return defaultOpt.option;
+  // Try each priority group in order
+  for (const group of SEED_PRIORITY_GROUPS) {
+    const matches = withQty.filter(x =>
+      x.qty > 0 && group.some(s => x.label.toLowerCase().includes(s))
+    );
+    if (matches.length > 0) {
+      const pick = matches[Math.floor(Math.random() * matches.length)];
+      LOG.info(`[farm:plant] seed group=[${group.join('/')}] picked="${pick.label}" qty=${pick.qty}`);
+      return pick.option;
+    }
+  }
 
+  // Fallback: highest qty
   const best = withQty.sort((a, b) => b.qty - a.qty)[0];
   return best?.option || options[0];
 }
@@ -1058,7 +1059,7 @@ async function waitForEditedMessage(channel, messageId, baselineText, timeoutMs
 // Determine the next action to take from the manage menu, given what the
 // farm image vision says about the current state.
 // Returns { action, button, reason } where action is null when the cycle is done.
-async function findNextFarmActionFromManage(msg, text, currentAction, imageAnalysis) {
+async function findNextFarmActionFromManage(msg, text, currentAction, imageAnalysis, forcedNextAction) {
   const btns = getAllButtons(msg).filter(b => !b.disabled && !isNavOrUtilityButton(b));
   const allBtns = getAllButtons(msg); // include disabled for state detection
   if (btns.length === 0) return { action: null, button: null, reason: 'no-buttons' };
@@ -1066,6 +1067,20 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
   const managedActions = getManageActionButtons(msg);
   const lower = String(stripAnsi(text || '')).toLowerCase();
 
+  // If we were explicitly told to try a specific action (e.g., advancing from hoe→water),
+  // skip the empty-farm default. If that action's button is also disabled,
+  // cascade through the rest of the phase order.
+  if (forcedNextAction) {
+    const phaseOrder = FARM_PHASE_ORDER;
+    const forcedIdx = phaseOrder.indexOf(forcedNextAction);
+    // Try forced action first, then cascade through remaining phases
+    for (let i = forcedIdx; i < phaseOrder.length; i++) {
+      const phase = phaseOrder[i];
+      const btn = managedActions[phase] || btns.find(b => hasAny(b, [phase]));
+      if (btn) return { action: phase, button: btn, reason: `forced(${forcedNextAction}→${phase})` };
+    }
+  }
+
   // If farm is empty, always start with hoe.
   if (/seems pretty empty|pretty empty|empty\.{0,3}/i.test(lower)) {
     const btn = managedActions.hoe || btns.find(b => hasAny(b, ['hoe', 'till']));
@@ -1142,7 +1157,7 @@ async function findNextFarmActionFromManage(msg, text, currentAction, imageAnaly
 async function advancePastConfirmation(response, waitForDankMemer) {
   if (!response) return null;
 
-  const CONFIRM_WORDS = ['continue', 'confirm', 'confirm all', 'done', 'back to farm', 'close'];
+  const CONFIRM_WORDS = ['continue', 'confirm', 'confirm all', 'done', 'back to farm', 'back', 'close'];
   const MAX_PAGES = 3;
 
   for (let page = 0; page < MAX_PAGES; page++) {
@@ -1212,9 +1227,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   await channel.send('pls farm view');
   let response = await waitForDankMemer(12000);
 
-  // eslint-disable-next-line no-console
-  console.log('[farm] runFarm entered — response=' + (response ? 'got-msg' : 'null'));
-
   if (!response) {
     LOG.warn('[farm] No response');
     return { result: 'no response', coins: 0, nextCooldownSec: 90 };
@@ -1261,7 +1273,7 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   const redisRecoveryMs = await getHarvestRecoveryMs(redis, accountId);
   const redisRecovered = redisRecoveryMs === 0;
   const growReadySec = parseFarmGrowReadySec(text);
-  const textHasHarvestReady = /ready to harvest|harvest ready|can be harvested|wilt/i.test(lower);
+  const textHasHarvestReady = /ready to harvest|harvest ready|can be harvested|wilts?/i.test(lower);
   if (textHasHarvestReady) LOG.info(`[farm] DETECTED harvest-ready in text (growReadySec=${growReadySec})`);
   if (growReadySec > 0) LOG.info(`[farm] GROW-QUEUE DEBUG: lower=${lower.slice(0, 400)}`);
   LOG.info(`[farm] grow-ready parse=${growReadySec == null ? 'none' : `${growReadySec}s`} redis_recovery=${redisRecoveryMs != null ? `${redisRecoveryMs}ms` : 'n/a'}`);
@@ -1275,8 +1287,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   }
 
   // Check for missing items on the initial farm view — buy and retry once.
-  // eslint-disable-next-line no-console
-  console.log('[farm] at vision check — text=' + brief(text, 200));
   const farmVision0 = analyzeFarmState({ msg: response, text });
   LOG.info(`[farm:vision] stage=${farmVision0.stage}${farmVision0.missing ? ` missing=${farmVision0.missing}` : ''}`);
   if (farmVision0.missing) {
@@ -1296,8 +1306,6 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   }
 
   // ── Open the manage menu ───────────────────────────────────────────────────
-  // eslint-disable-next-line no-console
-  console.log('[farm] at manage-btn check — text length=' + text.length + ' hasManage=' + (findFarmButton(response, ['manage']) ? 'yes' : 'no'));
   const manageBtn = findFarmButton(response, ['manage', 'farm-farm:manage']);
   if (manageBtn) {
     LOG.info('[farm] Opening Manage menu');
@@ -1330,21 +1338,19 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   let lastAction = null;
   let cycleResponse = response;
   let actionsTaken = 0; // Track how many farm actions were actually executed
+  let forcedNextAction = null; // When advancing a phase, force the next action check
+  let lastApplyResp = null; // Track the last apply response for coin/cooldown parsing
 
   while (cycleDepth < 5) {
-    // eslint-disable-next-line no-console
-    console.log('[farm] cycle iteration ' + cycleDepth + ' — cycleResponse type=' + (cycleResponse && cycleResponse.constructor ? cycleResponse.constructor.name : typeof cycleResponse));
     let actionResult;
     try {
-      actionResult = await findNextFarmActionFromManage(cycleResponse, text, lastAction, initialAnalysis);
+      actionResult = await findNextFarmActionFromManage(cycleResponse, text, lastAction, initialAnalysis, forcedNextAction);
     } catch (e) {
-      // eslint-disable-next-line no-console
-      console.log('[farm] findNextFarmActionFromManage ERROR:', e.message);
+      LOG.warn(`[farm:cycle] findNextFarmActionFromManage error: ${e.message}`);
       break;
     }
     const { action, button, reason } = actionResult;
-    // eslint-disable-next-line no-console
-    console.log('[farm] findNextFarmActionFromManage result: action=' + action + ' reason=' + reason);
+    forcedNextAction = null;
 
     if (!action || !button) {
       LOG.info(`[farm:cycle:${cycleDepth}] no action found (reason=${reason}) — breaking cycle`);
@@ -1397,37 +1403,93 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
       ' all', 'all ', 'all)', 'all:', ':all',
       'hoe all', 'water all', 'plant all', 'harvest all', 'confirm all',
     ]);
+
+    // If no enabled "All" button — check if it's disabled (farm is empty for this phase).
+    // If disabled, treat as a no-op and set forcedNextAction for the next iteration.
     if (!allBtn) {
+      const allBtnsInclDisabled = getAllButtons(cycleResponse);
+      const disabledAllBtn = allBtnsInclDisabled.find(b => {
+        const label = String(b.label || '').toLowerCase();
+        return (label.includes('all') || label.includes('hoe all') || label.includes('water all') ||
+          label.includes('plant all') || label.includes('harvest all') || label.includes('confirm')) && b.disabled;
+      });
+      if (disabledAllBtn) {
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        LOG.info(`[farm:cycle:${cycleDepth}] ${action} all-btn disabled (no-op) — next=${nextPhase || 'done'}`);
+        actionsTaken++;
+        lastAction = action;
+        forcedNextAction = nextPhase;
+        cycleDepth++;
+        if (!nextPhase) break;
+        initialAnalysis = null;
+        await sleep(300);
+        continue;
+      }
       LOG.info(`[farm:cycle:${cycleDepth}] no All button for ${action} — breaking cycle`);
       break;
     }
 
     LOG.info(`[farm:cycle:${cycleDepth}] applying ${action} with "${allBtn.label || '?'}"`);
     await humanDelay(90, 260);
-    const applyResp = await clickAndCapture({
+    lastApplyResp = await clickAndCapture({
       channel, waitForDankMemer, response: cycleResponse,
       button: allBtn, tag: `farm-cycle-${action}-apply`,
     });
     if (!applyResp) { LOG.warn('[farm:cycle] All click returned null'); break; }
 
     // Step 5: advance past any confirmation screens back to the manage menu
-    // Capture the confirmation screen text so we can detect no-ops.
-    const confirmationText = brief(getFullText(applyResp), 200);
     cycleResponse = await advancePastConfirmation(applyResp, waitForDankMemer);
     if (!cycleResponse) { LOG.warn('[farm:cycle] confirmation advance returned null'); break; }
-    // Action was successfully applied — count it
     actionsTaken++;
     lastAction = action;
+    text = getFullText(cycleResponse);
+    clean = brief(text, 600);
+    logFarmState('after-confirm', cycleResponse);
 
-    // If the confirmation screen text is the same as the post-confirmation text,
-    // the action was a no-op (e.g., hoe-ing already-tilled soil). Advance to the next phase.
-    const afterConfirmText = brief(getFullText(cycleResponse), 200);
-    if (afterConfirmText === confirmationText) {
+    // If confirmation screen is identical to post-confirmation screen,
+    // check whether we're on a planted confirmation (Dank Memer planted crops
+    // and shows "ready at X"). In that case, click "Back" to return to the
+    // farm view, then continue to harvest.
+    const confirmText = brief(getFullText(lastApplyResp), 200);
+    const afterText = brief(getFullText(cycleResponse), 200);
+    const afterLower = afterText.toLowerCase();
+    const isPlantedConfirmation = /potato|seeds ready|planted|crop.*ready|ready.*\d/i.test(afterLower);
+    const afterBtns = getAllButtons(cycleResponse);
+    const backBtn = afterBtns.find(b => !b.disabled && /back|back to farm/i.test(String(b.label || '').toLowerCase()));
+
+    if (afterText === confirmText) {
+      if (isPlantedConfirmation && backBtn) {
+        // Plant was successful — click "Back" to return to farm view, then proceed.
+        LOG.info(`[farm:cycle:${cycleDepth}] plant confirmed (crops planted) — clicking Back`);
+        await humanDelay(80, 200);
+        const backResp = await clickAndCapture({
+          channel, waitForDankMemer, response: cycleResponse,
+          button: backBtn, tag: `farm-cycle-${action}-back`,
+        });
+        if (backResp) {
+          cycleResponse = backResp;
+          text = getFullText(cycleResponse);
+          clean = brief(text, 600);
+          logFarmState('after-plant-back', cycleResponse);
+        }
+        // Plant succeeded — advance to harvest.
+        const currentIdx = FARM_PHASE_ORDER.indexOf(action);
+        const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
+        LOG.info(`[farm:cycle:${cycleDepth}] plant done, advancing to ${nextPhase || 'done'}`);
+        forcedNextAction = nextPhase;
+        if (!nextPhase) break;
+        cycleDepth++;
+        lastAction = nextPhase;
+        initialAnalysis = null;
+        await sleep(400);
+        continue;
+      }
+      // Truly a no-op (e.g., hoe-ing already-tilled soil).
       const currentIdx = FARM_PHASE_ORDER.indexOf(action);
       const nextPhase = FARM_PHASE_ORDER[currentIdx + 1] || null;
-      LOG.info(`[farm:cycle:${cycleDepth}] ${action} was no-op — advancing to ${nextPhase || 'done'}`);
-      text = getFullText(cycleResponse);
-      clean = brief(text, 600);
+      LOG.info(`[farm:cycle:${cycleDepth}] ${action} was no-op — next=${nextPhase || 'done'}`);
+      forcedNextAction = nextPhase;
       if (!nextPhase) break;
       cycleDepth++;
       lastAction = nextPhase;
@@ -1486,9 +1548,27 @@ async function runFarm({ channel, waitForDankMemer, client, redis, accountId })
   }
 
   // ── Parse final result ─────────────────────────────────────────────────────
-  const coins = parseCoins(text);
+  // If the cycle ended with a planted confirmation (harvest→plant→confirmed),
+  // the coins were shown on lastApplyResp (harvest confirmation). Parse from there too.
+  let coins = parseCoins(text);
+  if (coins <= 0 && lastApplyResp) {
+    const applyCoins = parseCoins(getFullText(lastApplyResp));
+    if (applyCoins > 0) coins = applyCoins;
+  }
   let nextCd = parseFarmCooldownSec(text) || 30;
   const growReadyEnd = parseFarmGrowReadySec(text);
+  // If the final screen is a planted confirmation, use its wilt timestamp as the
+  // grow queue timer — the crops are planted and will be ready at that time.
+  const finalLower = brief(text, 300).toLowerCase();
+  const isFinalPlanted = /potato|seeds ready|planted|crop.*ready|ready.*\d/i.test(finalLower);
+  if (isFinalPlanted && growReadyEnd === null) {
+    // Crops were planted. The wilt timestamp in the planted confirmation tells us
+    // when to harvest next. Set cooldown to that time, capped at a reasonable max.
+    const plantedCd = parseFarmCooldownSec(text);
+    if (plantedCd && plantedCd > 0) {
+      nextCd = Math.max(nextCd, Math.min(6 * 3600, plantedCd + 2));
+    }
+  }
   if (Number.isFinite(growReadyEnd) && growReadyEnd > 0) {
     nextCd = Math.max(nextCd, Math.min(6 * 3600, growReadyEnd + 2));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dankgrinder",
-  "version": "6.27.0",
+  "version": "6.34.0",
   "description": "Dank Memer automation engine — grind coins while you sleep",
   "bin": {
     "dankgrinder": "bin/dankgrinder.js"