honeytree 1.2.0 → 1.2.1

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() })
+    );
+  }
 }

package/src/renderer.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 
-import { getSprite, getGroundDetail, TREE_TYPES, GROUND_DETAIL_TYPES } from "./sprites.js";
+import { getSprite, getAncientSprite, getGroundDetail, TREE_TYPES, GROUND_DETAIL_TYPES } from "./sprites.js";
 import { getVirtualWidth } from "./plant.js";
 
 const SKY_ROWS = 4;
@@ -302,6 +302,34 @@ function buildStatsLine(forest, biome, viewportX = 0, virtualWidth = 0, termWidt
   );
 }
 
+export function getStatsData(forest, viewportX = 0, virtualWidth = 0, termWidth = 80) {
+  const treeCount = forest.trees.length;
+  const biome = getBiome(treeCount);
+  const milestone = getNextMilestone(treeCount);
+  const progress = milestone === 0 ? 0 : treeCount / milestone;
+  const streak = forest.streak || 0;
+  const wilt = getWiltFactor(forest.lastActiveDate);
+  let idleDays = 0;
+  if (wilt > 0 && forest.lastActiveDate) {
+    const a = new Date(forest.lastActiveDate + "T00:00:00");
+    const b = new Date(new Date().toISOString().slice(0, 10) + "T00:00:00");
+    idleDays = Math.round((b - a) / (24 * 60 * 60 * 1000));
+  }
+  return {
+    treeCount,
+    streak,
+    wilt,
+    idleDays,
+    milestone,
+    progress,
+    biomeName: biome.label,
+    nextTreeType: getNextTreeType(treeCount),
+    viewportX,
+    virtualWidth,
+    termWidth,
+  };
+}
+
 export function renderFrame(forest, termWidth = 80, options = {}) {
   const width = Math.max(40, termWidth);
   const treeCount = forest.trees.length;
@@ -333,11 +361,27 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   const windTick = options.windTick ?? null;
   const treeBaseY = groundStart - 1;
   const spriteOverride = options.spriteOverride ?? null;
+  const rewards = options.rewards ?? null;
+  const hasAncient = rewards && rewards.ancient;
+  const hasBloomer = rewards && rewards.cherry;
+
   for (const tree of forest.trees) {
     const yOffset = getTreeYOffset(tree.id);
-    const sprite = (spriteOverride && spriteOverride.treeId === tree.id)
-      ? spriteOverride.sprite
-      : getSprite(tree.type, tree.growth);
+    let sprite;
+    if (spriteOverride && spriteOverride.treeId === tree.id) {
+      sprite = spriteOverride.sprite;
+    } else if (hasAncient && hash(tree.id * 37) % 8 === 0) {
+      // Ancient: 1 in 8 trees become tall golden trees (still honor heightBonus)
+      sprite = getSprite(tree.type, tree.growth, {
+        heightBonus: tree.heightBonus || 0,
+        variant: "ancient",
+      });
+    } else {
+      sprite = getSprite(tree.type, tree.growth, {
+        heightBonus: tree.heightBonus || 0,
+        variant: tree.variant || null,
+      });
+    }
     const canopyShiftX = getWindOffset(tree.id, windTick);
     compositeSprite(buffer, sprite, tree.x, treeBaseY - yOffset, canopyShiftX);
   }
@@ -374,10 +418,26 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
 
   renderGroundDetails(buffer, biome, virtualWidth, groundStart);
 
+  // Reward: Bloomer — 30% of canopy █ chars become ✿ in pink
+  if (hasBloomer) {
+    for (let y = 0; y < groundStart; y++) {
+      for (let x = 0; x < virtualWidth; x++) {
+        const cell = buffer[y][x];
+        if (cell.char === "█" && cell.color && y < groundStart) {
+          if (hash(x * 71 + y * 113) % 10 < 3) {
+            cell.char = "✿";
+            cell.color = "#FFB7C5";
+          }
+        }
+      }
+    }
+  }
+
   applyFog(buffer, wilt, virtualWidth);
 
   // Slice the viewport from the virtual buffer
   const lines = [];
+
   for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS - CTA_ROWS; y += 1) {
     let line = "";
     for (let x = viewportX; x < viewportX + width; x += 1) {
@@ -392,12 +452,15 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
     lines.push(line);
   }
 
-  lines.push("");
-  lines.push(buildStatsLine(forest, biome, viewportX, virtualWidth, width));
-  lines.push(
-    chalk.hex("#555555")(" ← → pan  ·  add your forest to your README → ") +
-    chalk.hex(STATS_ACCENT)("honeytree badge"),
-  );
+  const includeStats = options.includeStats !== false;
+  if (includeStats) {
+    lines.push("");
+    lines.push(buildStatsLine(forest, biome, viewportX, virtualWidth, width));
+    lines.push(
+      chalk.hex("#555555")(" ← → pan  ·  add your forest to your README → ") +
+      chalk.hex(STATS_ACCENT)("honeytree badge"),
+    );
+  }
 
   return lines.join("\n");
 }
@@ -427,7 +490,12 @@ export function buildScene(forest, width) {
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
     const yOffset = getTreeYOffset(tree.id);
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
+    compositeSprite(
+      buffer,
+      getSprite(tree.type, tree.growth, { heightBonus: tree.heightBonus || 0, variant: tree.variant || null }),
+      tree.x,
+      treeBaseY - yOffset,
+    );
   }
 
   renderGroundDetails(buffer, biome, w, groundStart);
@@ -466,7 +534,12 @@ export function renderPlainText(forest, width = 60) {
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
     const yOffset = getTreeYOffset(tree.id);
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
+    compositeSprite(
+      buffer,
+      getSprite(tree.type, tree.growth, { heightBonus: tree.heightBonus || 0, variant: tree.variant || null }),
+      tree.x,
+      treeBaseY - yOffset,
+    );
   }
 
   const lines = [];

package/src/rewards.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { VARIETIES } from "./varieties.js";
+
+const REWARDS_FILE = path.join(os.homedir(), ".honeydew", "rewards.json");
+
+const TIERS = [
+  { slug: "cherry",  label: "Cherry Blossom", threshold: 1,  description: "Cherry blossom trees in your forest" },
+  { slug: "pine",    label: "Pine",           threshold: 5,  description: "Evergreen pines in your forest" },
+  { slug: "oak",     label: "Oak",            threshold: 10, description: "Broad oaks in your forest" },
+  { slug: "ancient", label: "Ancient",        threshold: 25, description: "Rare tall golden ancients" },
+  { slug: "mythic",  label: "Mythic",         threshold: 50, description: "Glowing mythic trees" },
+];
+
+export { TIERS };
+
+export function getRewards() {
+  try {
+    const data = JSON.parse(fs.readFileSync(REWARDS_FILE, "utf8"));
+    if (!Array.isArray(data.celebrated)) data.celebrated = [];
+    return data;
+  } catch {
+    return { badges: [], cherry: false, pine: false, oak: false, ancient: false, mythic: false, celebrated: [], username: "" };
+  }
+}
+
+export function saveRewards(data) {
+  const dir = path.dirname(REWARDS_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(REWARDS_FILE, JSON.stringify(data, null, 2));
+}
+
+export function hasReward(slug) {
+  return getRewards()[slug] === true;
+}
+
+// Back-compat alias used by the renderer's blossom branch.
+export function hasCherryBlossom() { return hasReward("cherry"); }
+
+// Fetch rewards from server and cache locally
+export async function syncRewards(apiUrl) {
+  apiUrl = apiUrl || process.env.HONEYTREE_API_URL || "https://tryhoney.xyz";
+  const { getAuth } = await import("./auth.js");
+  const auth = getAuth();
+  if (!auth || !auth.access_token) return null;
+
+  try {
+    const res = await fetch(`${apiUrl}/api/rewards`, {
+      headers: { Authorization: `Bearer ${auth.access_token}` },
+    });
+
+    if (!res.ok) return null;
+
+    const { rewards } = await res.json();
+    const unlocked = rewards.filter((r) => r.unlocked);
+    const slugs = unlocked.map((r) => r.slug);
+
+    const data = {
+      badges: unlocked.map((r) => ({ slug: r.slug, label: r.label, description: r.description })),
+      cherry: slugs.includes("cherry"),
+      pine: slugs.includes("pine"),
+      oak: slugs.includes("oak"),
+      ancient: slugs.includes("ancient"),
+      mythic: slugs.includes("mythic"),
+      celebrated: getRewards().celebrated,
+      username: auth.username || "",
+    };
+
+    saveRewards(data);
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+// Print rewards status to console
+export function printRewardsStatus(realTreesPlanted = 0) {
+  const rewards = getRewards();
+  console.log();
+  console.log("  Honeytree Rewards");
+  console.log("  ─────────────────");
+  for (const tier of TIERS) {
+    const unlocked = rewards[tier.slug] === true;
+    if (unlocked) {
+      console.log(`  ✅ ${tier.label} (${tier.threshold} tree${tier.threshold > 1 ? "s" : ""}) — ${tier.description}`);
+    } else {
+      const remaining = tier.threshold - realTreesPlanted;
+      const progress = remaining > 0 ? `${remaining} more real tree${remaining > 1 ? "s" : ""} to go` : "ready to unlock";
+      console.log(`  🔒 ${tier.label} (${tier.threshold} tree${tier.threshold > 1 ? "s" : ""}) — ${progress}`);
+    }
+  }
+  console.log();
+}
+
+// Unlocked variety keys (always includes "standard"), read from the local cache.
+export function getUnlockedVarietyKeys() {
+  const r = getRewards();
+  return VARIETIES.filter((v) => v.key === "standard" || r[v.key] === true).map((v) => v.key);
+}
+
+// Mark a variety's celebration as shown (idempotent).
+export function markCelebrated(key) {
+  const r = getRewards();
+  if (!Array.isArray(r.celebrated)) r.celebrated = [];
+  if (!r.celebrated.includes(key)) {
+    r.celebrated.push(key);
+    saveRewards(r);
+  }
+}
+
+// Unlocked varieties (excluding standard) whose celebration has not been shown.
+export function uncelebratedUnlocked() {
+  const r = getRewards();
+  const celebrated = new Set(r.celebrated || []);
+  return VARIETIES
+    .filter((v) => v.key !== "standard" && r[v.key] === true && !celebrated.has(v.key))
+    .map((v) => v.key);
+}

package/src/session.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getHoneydewDir } from "./state.js";
+
+const STALE_MS = 5 * 60 * 1000; // a turn older than this is abandoned
+
+function sessionFile() {
+  return path.join(getHoneydewDir(), "active-session.json");
+}
+
+export function writeActiveSession(data) {
+  const dir = getHoneydewDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(sessionFile(), JSON.stringify(data, null, 2));
+}
+
+export function readActiveSession() {
+  try {
+    return JSON.parse(fs.readFileSync(sessionFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function clearActiveSession() {
+  try {
+    fs.unlinkSync(sessionFile());
+  } catch {}
+}
+
+export function isStale(session, now = Date.now()) {
+  if (!session || typeof session.turnStartedAt !== "number") return true;
+  return now - session.turnStartedAt > STALE_MS;
+}

package/src/sprites.js

@@ -14,6 +14,30 @@ const COLORS = {
   cherryBloom: "#f0b7cf",
 };
 
+const BLOSSOM_COLORS = {
+  petalSoft: "#f7d1e0",
+  petalBright: "#ffa6c9",
+  petalDeep: "#e87aab",
+  branch: "#a67c5b",
+};
+
+// Teal palette for "Grove" status unlock
+// Gold palette for "Ancient Forest" tall trees
+export const GOLD_COLORS = {
+  canopyTop: "#FFD700",
+  canopyMid: "#DAA520",
+  canopyDark: "#B8860B",
+  trunk: "#8B7355",
+};
+
+// Mythic palette — glowing unicode treatment.
+const MYTHIC_COLORS = {
+  glow: "#b388ff",
+  glowBright: "#e0c3fc",
+  core: "#7c4dff",
+  trunk: "#5e35b1",
+};
+
 const DETAIL_COLORS = {
   mushroom: "#c4a882",
   mushroomCap: "#9e4a3a",
@@ -240,8 +264,32 @@ pPPpPPPp
       { p: COLORS.cherryBloom, P: COLORS.cherryPink, t: COLORS.trunkLight },
     ),
   },
+  cherry_blossom: {
+    seed: parse(` p\n b`, { p: BLOSSOM_COLORS.petalSoft, b: BLOSSOM_COLORS.branch }),
+    sapling: parse(` pP\npBp\n b`, { p: BLOSSOM_COLORS.petalSoft, P: BLOSSOM_COLORS.petalBright, B: BLOSSOM_COLORS.petalDeep, b: BLOSSOM_COLORS.branch }),
+    young: parse(`  PB\n PpBp\npBPpBP\n  bb\n  bb`, { p: BLOSSOM_COLORS.petalSoft, P: BLOSSOM_COLORS.petalBright, B: BLOSSOM_COLORS.petalDeep, b: BLOSSOM_COLORS.branch }),
+    full: parse(`   PBp\n pBPPBp\nPBpPBPBP\n pBPPBp\n   bb\n   bb`, { p: BLOSSOM_COLORS.petalSoft, P: BLOSSOM_COLORS.petalBright, B: BLOSSOM_COLORS.petalDeep, b: BLOSSOM_COLORS.branch }),
+  },
+  mythic: {
+    seed: parse(`\n m\n t\n`, { m: MYTHIC_COLORS.glow, t: MYTHIC_COLORS.trunk }),
+    sapling: parse(`\n mm\nmGm\n t\n`, { m: MYTHIC_COLORS.glow, G: MYTHIC_COLORS.glowBright, t: MYTHIC_COLORS.trunk }),
+    young: parse(`\n  mG\n mGGm\nmGGcGm\n  tt\n  tt\n`, { m: MYTHIC_COLORS.glow, G: MYTHIC_COLORS.glowBright, c: MYTHIC_COLORS.core, t: MYTHIC_COLORS.trunk }),
+    full: parse(`\n   mGm\n mGGGGm\nmGGccGGm\n mGGGGm\n   tt\n   tt\n`, { m: MYTHIC_COLORS.glow, G: MYTHIC_COLORS.glowBright, c: MYTHIC_COLORS.core, t: MYTHIC_COLORS.trunk }),
+  },
+};
+
+// Tall golden tree for "Ancient Forest" reward (1 in 8 trees)
+const ANCIENT_TREE = {
+  seed: parse(` g\n t`, { g: GOLD_COLORS.canopyTop, t: GOLD_COLORS.trunk }),
+  sapling: parse(` gg\ngGg\n t`, { g: GOLD_COLORS.canopyTop, G: GOLD_COLORS.canopyMid, t: GOLD_COLORS.trunk }),
+  young: parse(`  Tg\n TGGg\nTgGGgT\n  tt\n  tt\n  tt`, { g: GOLD_COLORS.canopyMid, G: GOLD_COLORS.canopyDark, T: GOLD_COLORS.canopyTop, t: GOLD_COLORS.trunk }),
+  full: parse(`   TT\n  TGGT\n TgGGGgT\nTgGGGGgT\n TgGGGg\n   tt\n   tt\n   tt`, { g: GOLD_COLORS.canopyMid, G: GOLD_COLORS.canopyDark, T: GOLD_COLORS.canopyTop, t: GOLD_COLORS.trunk }),
 };
 
+export function getAncientSprite(growth) {
+  return ANCIENT_TREE[getGrowthStage(growth)];
+}
+
 const GROUND_DETAILS = {
   mushroom: parse(
     `
@@ -293,11 +341,28 @@ function getGrowthStage(growth) {
   return "full";
 }
 
-export function getSprite(type, growth) {
-  const spriteSet = SPRITES[type];
-  if (!spriteSet) {
-    throw new Error(`Unknown tree type: ${type}`);
+// rows are stored bottom-first (row[0] is the ground row). Adding trunk rows at
+// the bottom makes the trunk taller and pushes the canopy up.
+function addTrunkRows(sprite, n) {
+  const bottom = sprite.rows[0] || [];
+  const trunkRow = bottom.map((cell) => (cell && cell[1] ? ["█", cell[1]] : [" ", null]));
+  const extra = Array.from({ length: n }, () => trunkRow.map((c) => [c[0], c[1]]));
+  return { rows: [...extra, ...sprite.rows], width: sprite.width };
+}
+
+export function getSprite(type, growth, opts = {}) {
+  const { heightBonus = 0, variant = null } = opts;
+  let sprite;
+  if (variant === "ancient") {
+    sprite = getAncientSprite(growth);
+  } else {
+    const spriteSet = SPRITES[type];
+    if (!spriteSet) {
+      throw new Error(`Unknown tree type: ${type}`);
+    }
+    sprite = spriteSet[getGrowthStage(growth)];
   }
-  return spriteSet[getGrowthStage(growth)];
+  if (heightBonus > 0) sprite = addTrunkRows(sprite, heightBonus);
+  return sprite;
 }
 

package/src/stdin.js

@@ -0,0 +1,28 @@
+// Read a hook's JSON payload from stdin. Resolves "" if stdin is a TTY/empty
+// (e.g. when the command is run manually), so callers can fall back gracefully.
+export function readStdin(timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(data);
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (data += c));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      finish();
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      finish();
+    });
+  });
+}