honeytree 1.1.6 → 1.2.1

package/src/components/StatsBar.js

@@ -0,0 +1,70 @@
+import React, { useMemo } from "react";
+import { Box, Text } from "ink";
+
+import { getStatsData } from "../renderer.js";
+import { getVirtualWidth } from "../plant.js";
+
+const h = React.createElement;
+
+const STATS_ACCENT = "#f5a50b";
+const STATS_TEXT = "#8e8a84";
+const STATS_WARN = "#c4653a";
+const STREAK_COLOR = "#e8a33a";
+const BAR_FILL = "#6cb95e";
+const BAR_EMPTY = "#3d3d3d";
+
+export default function StatsBar({ forest, viewportX, termWidth, rewards }) {
+  const vw = getVirtualWidth(forest.trees.length, termWidth);
+  const stats = useMemo(
+    () => getStatsData(forest, viewportX, vw, termWidth),
+    [forest, viewportX, vw, termWidth],
+  );
+
+  const barWidth = 12;
+  const filledWidth = Math.max(0, Math.min(barWidth, Math.round(stats.progress * barWidth)));
+
+  // Minimap
+  let minimap = null;
+  if (stats.virtualWidth > stats.termWidth) {
+    const mapWidth = 12;
+    const viewFraction = stats.termWidth / stats.virtualWidth;
+    const thumbWidth = Math.max(1, Math.round(viewFraction * mapWidth));
+    const maxOffset = stats.virtualWidth - stats.termWidth;
+    const thumbPos = maxOffset > 0
+      ? Math.round((stats.viewportX / maxOffset) * (mapWidth - thumbWidth))
+      : 0;
+    const mapBar =
+      "─".repeat(thumbPos) +
+      "═".repeat(thumbWidth) +
+      "─".repeat(mapWidth - thumbPos - thumbWidth);
+    minimap = h(Text, null,
+      h(Text, { color: STATS_TEXT }, " ["),
+      h(Text, { color: BAR_FILL }, mapBar),
+      h(Text, { color: STATS_TEXT }, "]"),
+    );
+  }
+
+  const streakSegment = stats.wilt > 0
+    ? h(Text, { color: STATS_WARN }, `wilting (${stats.idleDays}d idle)`)
+    : stats.streak > 0
+      ? h(Text, { color: STREAK_COLOR }, `${stats.streak}-day streak`)
+      : h(Text, { color: STATS_TEXT }, "no streak");
+
+  return h(Box, { flexDirection: "column" },
+    h(Box, null,
+      h(Text, { color: STATS_ACCENT }, " honeytree"),
+      h(Text, { color: STATS_TEXT }, ` · ${stats.treeCount} tree${stats.treeCount === 1 ? "" : "s"} · `),
+      streakSegment,
+      h(Text, { color: STATS_TEXT }, " · "),
+      h(Text, { color: BAR_FILL }, "█".repeat(filledWidth)),
+      h(Text, { color: BAR_EMPTY }, "░".repeat(barWidth - filledWidth)),
+      h(Text, { color: STATS_TEXT }, ` next: ${stats.nextTreeType}`),
+      h(Text, { color: "#555555" }, ` [${stats.biomeName}]`),
+      minimap,
+    ),
+    h(Box, null,
+      h(Text, { color: "#555555" }, " ← → pan  · ↑↓ select tree  · enter info  · q quit  ·  "),
+      h(Text, { color: STATS_ACCENT }, "honeytree badge"),
+    ),
+  );
+}

package/src/components/TreeInfoPopup.js

@@ -0,0 +1,28 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+const h = React.createElement;
+
+export default function TreeInfoPopup({ tree }) {
+  if (!tree) return null;
+
+  const growthPct = Math.round(tree.growth * 100);
+  const plantedDate = tree.plantedAt
+    ? new Date(tree.plantedAt).toLocaleDateString()
+    : "unknown";
+
+  let age = "";
+  if (tree.plantedAt) {
+    const days = Math.floor((Date.now() - new Date(tree.plantedAt).getTime()) / (24 * 60 * 60 * 1000));
+    age = days === 0 ? "today" : days === 1 ? "1 day" : `${days} days`;
+  }
+
+  return h(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f5a50b", paddingX: 1 },
+    h(Text, { bold: true, color: "#f5a50b" }, ` ${tree.type} `),
+    h(Text, { color: "#8e8a84" }, `  Growth:  ${growthPct}%`),
+    h(Text, { color: "#8e8a84" }, `  Planted: ${plantedDate}`),
+    age ? h(Text, { color: "#8e8a84" }, `  Age:     ${age}`) : null,
+    h(Text, { color: "#8e8a84" }, `  ID:      ${tree.id}`),
+    h(Text, { dimColor: true }, `  [esc] close`),
+  );
+}

package/src/components/UnlockCelebration.js

@@ -0,0 +1,40 @@
+import React from "react";
+import { Box, Text, useInput } from "ink";
+import { VARIETIES } from "../varieties.js";
+
+const h = React.createElement;
+
+// ASCII reveal art per variety (screenshot-worthy, terminal-safe).
+const ART = {
+  cherry: "  .::.\n.:(@@):.\n :(@@): \n   ||   ",
+  pine: "    ^\n   /^\\\n  /^^^\\\n /^^^^^\\\n   |||  ",
+  oak: "   ___\n  (###)\n (#####)\n  (###)\n   |||  ",
+  ancient: "  *___*\n (#####)\n(#######)\n (#####)\n  |||||  ",
+  mythic: "  *. .*\n .*###*.\n*#######*\n .*###*.\n  |||||  ",
+};
+
+export function celebrationFor(key) {
+  const v = VARIETIES.find((x) => x.key === key);
+  return {
+    label: v ? v.label : key,
+    art: ART[key] || "  ###\n (###)\n  |||",
+  };
+}
+
+// Full-screen celebration. Calls onDismiss() when the user presses any key.
+export default function UnlockCelebration({ varietyKey, onDismiss }) {
+  const { label, art } = celebrationFor(varietyKey);
+  useInput(() => onDismiss());
+
+  return h(
+    Box,
+    { flexDirection: "column", alignItems: "center", justifyContent: "center", height: 18, width: "100%" },
+    h(Text, { color: "#f5a50b", bold: true }, "✦  NEW TREE VARIETY UNLOCKED  ✦"),
+    h(Box, { height: 1 }),
+    h(Text, { color: "#b388ff" }, art),
+    h(Box, { height: 1 }),
+    h(Text, { bold: true }, label),
+    h(Box, { height: 1 }),
+    h(Text, { dimColor: true }, "Screenshot this — then press any key to enter your forest")
+  );
+}

package/src/growth.js

@@ -0,0 +1,32 @@
+// Pure mapping from a turn's output-token count to a tree's shape.
+// Tunable: change these to reshape the forest's "honesty" curve.
+export const GROWTH = {
+  SAPLING_MAX: 250,
+  FULL_TOKENS: 1500,
+  MONSTER_TOKENS: 4000,
+  MAX_HEIGHT_BONUS: 4,
+};
+
+export function tokensToTree(tokens) {
+  const n = Number.isFinite(tokens) && tokens > 0 ? tokens : 0;
+
+  let growth;
+  if (n < GROWTH.SAPLING_MAX) {
+    growth = 0.15 + (n / GROWTH.SAPLING_MAX) * 0.2; // 0.15 .. 0.35
+  } else if (n < GROWTH.FULL_TOKENS) {
+    const r = (n - GROWTH.SAPLING_MAX) / (GROWTH.FULL_TOKENS - GROWTH.SAPLING_MAX);
+    growth = 0.35 + r * 0.65; // 0.35 .. 1.0
+  } else {
+    growth = 1;
+  }
+
+  let heightBonus = 0;
+  if (n > GROWTH.FULL_TOKENS) {
+    const over =
+      (n - GROWTH.FULL_TOKENS) / (GROWTH.MONSTER_TOKENS - GROWTH.FULL_TOKENS);
+    heightBonus = Math.min(GROWTH.MAX_HEIGHT_BONUS, Math.max(1, Math.ceil(over * GROWTH.MAX_HEIGHT_BONUS)));
+  }
+
+  // Variant (species/look) is owned by the variety system, not token count.
+  return { growth: Math.min(1, Math.round(growth * 100) / 100), heightBonus, variant: null };
+}

package/src/init.js

@@ -20,7 +20,17 @@ const HONEYDEW_STOP_HOOK = {
   hooks: [
     {
       type: "command",
-      command: "honeytree plant",
+      command: "honeytree __tick",
+    },
+  ],
+};
+
+const HONEYDEW_SESSION_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "honeytree __session",
     },
   ],
 };
@@ -28,11 +38,34 @@ const HONEYDEW_STOP_HOOK = {
 function hasHoneydewHook(settings) {
   return (
     settings?.hooks?.Stop?.some((entry) =>
-      entry?.hooks?.some((hook) => hook?.command === "honeytree plant"),
+      entry?.hooks?.some((hook) => hook?.command === "honeytree __tick"),
     ) ?? false
   );
 }
 
+function hasSessionHook(settings) {
+  return (
+    settings?.hooks?.UserPromptSubmit?.some((entry) =>
+      entry?.hooks?.some((hook) => hook?.command === "honeytree __session"),
+    ) ?? false
+  );
+}
+
+// Rewrite any legacy `honeytree plant` Stop hook to the new hidden `__tick`.
+// Returns true if anything changed.
+function migrateLegacyHook(settings) {
+  let changed = false;
+  for (const entry of settings?.hooks?.Stop ?? []) {
+    for (const hook of entry?.hooks ?? []) {
+      if (hook?.command === "honeytree plant") {
+        hook.command = "honeytree __tick";
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+
 export async function init() {
   const honeydewDir = getHoneydewDir();
   fs.mkdirSync(honeydewDir, { recursive: true });
@@ -72,6 +105,12 @@ export async function init() {
   settings.hooks ??= {};
   settings.hooks.Stop ??= [];
 
+  const migrated = migrateLegacyHook(settings);
+  if (migrated) {
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    console.log(`Migrated legacy honeytree hook to __tick in ${settingsPath}`);
+  }
+
   if (hasHoneydewHook(settings)) {
     console.log(`Claude Code hook already configured in ${settingsPath}`);
   } else {
@@ -80,6 +119,13 @@ export async function init() {
     console.log(`Added honeytree Stop hook to ${settingsPath}`);
   }
 
+  settings.hooks.UserPromptSubmit ??= [];
+  if (!hasSessionHook(settings)) {
+    settings.hooks.UserPromptSubmit.push(HONEYDEW_SESSION_HOOK);
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    console.log(`Added honeytree UserPromptSubmit hook to ${settingsPath}`);
+  }
+
   console.log("");
   console.log("Setup complete.");
   console.log("Run `honeytree` in a separate terminal to watch the forest grow.");

package/src/plant-real.js

@@ -0,0 +1,129 @@
+import { execFile } from "node:child_process";
+import { isLoggedIn, loginWithDevice, getAuth } from "./auth.js";
+import { readForest } from "./state.js";
+import { syncToCloud } from "./sync.js";
+import { asciiTree } from "./ascii-tree.js";
+
+const API_URL = process.env.HONEYTREE_API_URL || "https://tryhoney.xyz";
+const POLL_INTERVAL_MS = 4000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000;
+
+// ---- Pure helpers (unit-tested) ----
+
+export function formatAvailability({ available, virtualTrees, virtualToNext }) {
+  const lines = [];
+  lines.push("");
+  lines.push("  50 virtual trees = 1 real tree.");
+  if (available >= 1) {
+    lines.push(`  You have ${available} real tree${available > 1 ? "s" : ""} ready to plant.`);
+  } else {
+    lines.push("  No real trees ready to plant yet.");
+  }
+  lines.push(`  ${virtualToNext} virtual trees until your next one. (${virtualTrees} planted so far.)`);
+  lines.push("");
+  return lines;
+}
+
+export function findNewCompletedPlantings(baselineIds, currentPlantings) {
+  const seen = new Set(baselineIds);
+  return (currentPlantings || []).filter((p) => p.status === "completed" && !seen.has(p.id));
+}
+
+export function findNewBadgeLabels(baselineSlugs, currentBadges) {
+  const seen = new Set(baselineSlugs);
+  return (currentBadges || [])
+    .filter((b) => b.unlocked && !seen.has(b.slug))
+    .map((b) => b.label);
+}
+
+// ---- I/O glue ----
+
+function openBrowser(url) {
+  // Use execFile (no shell) so the URL is passed as a literal argument, never
+  // interpolated into a shell command. On Windows, `start` is a cmd builtin.
+  const [cmd, args] =
+    process.platform === "darwin" ? ["open", [url]] :
+    process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] :
+    ["xdg-open", [url]];
+  execFile(cmd, args, (err) => {
+    if (err) console.warn(`  (Could not open the browser automatically — visit ${url})`);
+  });
+}
+
+async function fetchStats() {
+  const auth = getAuth();
+  if (!auth?.access_token) return null;
+  try {
+    const res = await fetch(`${API_URL}/api/user/stats`, {
+      headers: { Authorization: `Bearer ${auth.access_token}` },
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+export async function plant() {
+  if (!isLoggedIn()) {
+    console.log("  Linking your terminal first...");
+    const ok = await loginWithDevice();
+    if (!ok) return;
+  }
+
+  // Make sure the server has the latest virtual count.
+  const forest = readForest();
+  if (forest) await syncToCloud(forest);
+
+  const stats = await fetchStats();
+  if (!stats) {
+    console.log("  Could not reach Honeytree. Try again in a moment.");
+    return;
+  }
+
+  for (const line of formatAvailability({
+    available: stats.available_to_plant ?? 0,
+    virtualTrees: stats.virtual_trees ?? 0,
+    virtualToNext: stats.virtual_to_next ?? 50,
+  })) {
+    console.log(line);
+  }
+
+  if ((stats.available_to_plant ?? 0) < 1) {
+    return;
+  }
+
+  const baselineIds = (stats.plantings || []).map((p) => p.id);
+  const baselineBadgeSlugs = (stats.badges || []).filter((b) => b.unlocked).map((b) => b.slug);
+
+  const url = `${API_URL}/dashboard?plant=1`;
+  console.log(`  Opening ${url}`);
+  console.log("  Complete your payment in the browser — I'll wait here.");
+  openBrowser(url);
+
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    const latest = await fetchStats();
+    if (!latest) continue;
+    const newlyPlanted = findNewCompletedPlantings(baselineIds, latest.plantings);
+    if (newlyPlanted.length === 0) continue;
+
+    const treesPlanted = newlyPlanted.reduce((s, p) => s + (p.real_trees_planted || 0), 0);
+    const newBadges = findNewBadgeLabels(baselineBadgeSlugs, latest.badges);
+    const hasBloomer = (latest.badges || []).some((b) => b.slug === "cherry" && b.unlocked);
+
+    console.log("");
+    console.log(asciiTree(hasBloomer));
+    console.log(`  🌳 Planted ${treesPlanted} real tree${treesPlanted > 1 ? "s" : ""}!`);
+    console.log(`  You've now planted ${latest.real_trees_planted} real tree${latest.real_trees_planted > 1 ? "s" : ""} total.`);
+    for (const label of newBadges) {
+      console.log(`  🏅 ${label} unlocked!`);
+    }
+    console.log("  A receipt is on its way to your email.");
+    console.log("");
+    return;
+  }
+
+  console.log("  Still processing — check your dashboard, or run `honeytree plant` again.");
+}

package/src/plant.js

@@ -1,7 +1,14 @@
-import { getSprite, TREE_TYPES } from "./sprites.js";
+import { getSprite } from "./sprites.js";
+import { getUnlockedVarietyKeys } from "./rewards.js";
+import { unlockedPool, pickSpecies } from "./varieties.js";
 import { createEmptyForest, readForest, writeForest } from "./state.js";
 import { findBadgeFile, writeBadgeSVG } from "./badge.js";
 import { migrateLayout } from "./migrate.js";
+import { isLoggedIn } from "./auth.js";
+import { syncToCloud } from "./sync.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
 
 const MIN_GAP = 6;
 const DEFAULT_WIDTH = 80;
@@ -11,7 +18,7 @@ export function getVirtualWidth(treeCount, termWidth) {
   return Math.max(termWidth, treeCount * TREE_SPACING);
 }
 
-function getPlantWidth(forest) {
+export function getPlantWidth(forest) {
   const termWidth = forest.viewerWidth && forest.viewerWidth > 40
     ? forest.viewerWidth
     : DEFAULT_WIDTH;
@@ -19,10 +26,6 @@ function getPlantWidth(forest) {
   return getVirtualWidth(treeCount, termWidth);
 }
 
-function randomItem(items) {
-  return items[Math.floor(Math.random() * items.length)];
-}
-
 function randomGrowth() {
   return Math.round((0.3 + Math.random() * 0.7) * 100) / 100;
 }
@@ -35,7 +38,7 @@ function occupiedRanges(trees) {
   });
 }
 
-function findOpenX(trees, type, growth, width) {
+export function findOpenX(trees, type, growth, width) {
   const sprite = getSprite(type, growth);
   const half = Math.floor(sprite.width / 2);
   const margin = half + 1;
@@ -68,7 +71,7 @@ function daysBetween(dateA, dateB) {
   return Math.round(Math.abs(b - a) / (24 * 60 * 60 * 1000));
 }
 
-export async function plant() {
+export async function tick(shape = null) {
   const forest = readForest() ?? createEmptyForest();
   const width = getPlantWidth(forest);
 
@@ -101,17 +104,21 @@ export async function plant() {
     tree.growth = nudgeGrowth(tree.growth);
   }
 
-  const type = randomItem(TREE_TYPES);
-  const growth = randomGrowth();
+  let type = shape?.type;
+  let variant = shape?.variant ?? null;
+  if (!type) {
+    const species = pickSpecies(unlockedPool(getUnlockedVarietyKeys()));
+    type = species.type;
+    variant = species.variant ?? null;
+  }
+  const growth = typeof shape?.growth === "number" ? shape.growth : randomGrowth();
   const nextId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0) + 1;
+  const x = typeof shape?.x === "number" ? shape.x : findOpenX(forest.trees, type, growth, width);
 
-  forest.trees.push({
-    id: nextId,
-    type,
-    growth,
-    x: findOpenX(forest.trees, type, growth, width),
-    plantedAt: new Date().toISOString(),
-  });
+  const tree = { id: nextId, type, growth, x, plantedAt: new Date().toISOString() };
+  if (shape?.heightBonus) tree.heightBonus = shape.heightBonus;
+  if (variant) tree.variant = variant;
+  forest.trees.push(tree);
   forest.totalPrompts += 1;
 
   writeForest(forest);
@@ -121,4 +128,19 @@ export async function plant() {
     const badgePath = findBadgeFile();
     if (badgePath) writeBadgeSVG(forest, badgePath);
   } catch {}
+
+  // Cloud sync every 10 prompts (fire-and-forget)
+  if (isLoggedIn() && forest.totalPrompts % 10 === 0) {
+    syncToCloud(forest).catch(() => {});
+  }
+
+  // Milestone check at every 50 prompts — unlocks 1 real tree planting
+  if (isLoggedIn() && forest.totalPrompts > 0 && forest.totalPrompts % 50 === 0) {
+    const milestoneFile = path.join(os.homedir(), ".honeydew", "milestone.json");
+    fs.mkdirSync(path.dirname(milestoneFile), { recursive: true });
+    fs.writeFileSync(
+      milestoneFile,
+      JSON.stringify({ totalPrompts: forest.totalPrompts, timestamp: Date.now() })
+    );
+  }
 }