honeytree 1.1.6 → 1.2.1

package/src/animation.js

@@ -0,0 +1,151 @@
+import { ANIMATION_KEYFRAMES } from "./animation-keyframes.js";
+import { getSprite } from "./sprites.js";
+
+const CHAR_ORDER = [" ", "░", "▒", "█"];
+
+function charIndex(ch) {
+  const idx = CHAR_ORDER.indexOf(ch);
+  return idx >= 0 ? idx : 0;
+}
+
+function interpolateChar(ch1, ch2, t) {
+  const i1 = charIndex(ch1);
+  const i2 = charIndex(ch2);
+  const idx = Math.round(i1 + (i2 - i1) * t);
+  return CHAR_ORDER[Math.max(0, Math.min(CHAR_ORDER.length - 1, idx))];
+}
+
+function parseHex(hex) {
+  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+  };
+}
+
+function toHex({ r, g, b }) {
+  const c = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return `#${c(r)}${c(g)}${c(b)}`;
+}
+
+function lerpColor(hex1, hex2, t) {
+  const c1 = parseHex(hex1);
+  const c2 = parseHex(hex2);
+  return toHex({
+    r: c1.r + (c2.r - c1.r) * t,
+    g: c1.g + (c2.g - c1.g) * t,
+    b: c1.b + (c2.b - c1.b) * t,
+  });
+}
+
+function interpolateSprite(sprite1, sprite2, t) {
+  const rows = sprite1.rows.map((row, r) =>
+    row.map(([ch1, col1], c) => {
+      const [ch2, col2] = sprite2.rows[r][c];
+      if (!col1 && !col2) return [" ", null];
+      if (!col1 && col2) {
+        const ch = interpolateChar(" ", ch2, t);
+        if (ch === " ") return [" ", null];
+        return [ch, col2];
+      }
+      if (col1 && !col2) {
+        const ch = interpolateChar(ch1, " ", t);
+        if (ch === " ") return [" ", null];
+        return [ch, col1];
+      }
+      const ch = interpolateChar(ch1, ch2, t);
+      const col = lerpColor(col1, col2, t);
+      return [ch, col];
+    }),
+  );
+  return { rows, width: sprite1.width };
+}
+
+function brightenSprite(sprite, amount) {
+  const rows = sprite.rows.map((row) =>
+    row.map(([ch, col]) => {
+      if (!col) return [ch, col];
+      const c = parseHex(col);
+      return [ch, toHex({
+        r: Math.min(255, c.r + (255 - c.r) * amount),
+        g: Math.min(255, c.g + (255 - c.g) * amount),
+        b: Math.min(255, c.b + (255 - c.b) * amount),
+      })];
+    }),
+  );
+  return { rows, width: sprite.width };
+}
+
+export function getAnimationFrames(type, growth, frameCount = 40) {
+  const allKeyframes = ANIMATION_KEYFRAMES[type];
+  if (!allKeyframes) throw new Error(`No animation keyframes for type: ${type}`);
+
+  const finalSprite = getSprite(type, growth);
+
+  let keyframes;
+  if (growth >= 0.8) {
+    keyframes = allKeyframes;
+  } else {
+    let maxKF;
+    if (growth < 0.2) maxKF = 3;
+    else if (growth < 0.5) maxKF = 6;
+    else maxKF = 8;
+
+    keyframes = allKeyframes.slice(0, maxKF);
+    const lastTime = keyframes[keyframes.length - 1].time;
+    const timeScale = 4.0 / Math.max(lastTime, 0.1);
+
+    keyframes = keyframes.map((kf) => ({ ...kf, time: kf.time * timeScale }));
+    keyframes.push({ time: 4.0, sprite: finalSprite });
+    keyframes.push({ time: 4.5, sprite: brightenSprite(finalSprite, 0.2) });
+  }
+
+  const totalDuration = 5.0;
+  const frames = [];
+
+  for (let i = 0; i < frameCount; i++) {
+    const t = (i / (frameCount - 1)) * totalDuration;
+
+    let kfBefore = keyframes[0];
+    let kfAfter = keyframes[0];
+
+    for (let k = 0; k < keyframes.length - 1; k++) {
+      if (t >= keyframes[k].time && t <= keyframes[k + 1].time) {
+        kfBefore = keyframes[k];
+        kfAfter = keyframes[k + 1];
+        break;
+      }
+      if (k === keyframes.length - 2) {
+        kfBefore = keyframes[keyframes.length - 1];
+        kfAfter = keyframes[keyframes.length - 1];
+      }
+    }
+
+    const segmentDuration = kfAfter.time - kfBefore.time;
+    const segmentT = segmentDuration > 0 ? (t - kfBefore.time) / segmentDuration : 1;
+    const clampedT = Math.max(0, Math.min(1, segmentT));
+
+    const sprite = interpolateSprite(kfBefore.sprite, kfAfter.sprite, clampedT);
+
+    let groundOverlay = null;
+    if (t < 0.5 && kfBefore.groundEffect) {
+      const ge = kfBefore.groundEffect;
+      groundOverlay = [];
+      for (let dx = -ge.radius; dx <= ge.radius; dx++) {
+        const intensity = 1 - Math.abs(dx) / ge.radius;
+        if (intensity > 0.3) {
+          groundOverlay.push({ dx, char: "░", color: ge.color });
+        }
+      }
+    }
+
+    if (i === frameCount - 1) {
+      frames.push({ sprite: finalSprite, groundOverlay: null, groundPulse: false });
+    } else {
+      frames.push({ sprite, groundOverlay, groundPulse: i < 3 });
+    }
+  }
+
+  return frames;
+}

package/src/ascii-tree.js

@@ -0,0 +1,21 @@
+const TREE = `
+       /\\
+      /  \\
+     /    \\
+    /______\\
+       ||
+       ||
+`;
+
+const TREE_BLOSSOM = `
+      .::.
+    .:(@@):.
+   :(@@@@@@):
+    ':(@@):'
+       ||
+       ||
+`;
+
+export function asciiTree(hasBloomer) {
+  return hasBloomer ? TREE_BLOSSOM : TREE;
+}

package/src/auth.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const AUTH_DIR = path.join(os.homedir(), ".honeydew");
+const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+
+export function getAuth() {
+  try {
+    return JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveAuth(data) {
+  fs.mkdirSync(AUTH_DIR, { recursive: true });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2));
+}
+
+export function clearAuth() {
+  try {
+    fs.unlinkSync(AUTH_FILE);
+  } catch {}
+}
+
+export function isLoggedIn() {
+  const auth = getAuth();
+  return !!(auth && auth.access_token);
+}
+
+export async function loginWithDevice(apiUrl = process.env.HONEYTREE_API_URL || "https://tryhoney.xyz") {
+  const res = await fetch(`${apiUrl}/api/auth/device`, { method: "POST" });
+  const contentType = res.headers.get("content-type") || "";
+  if (!contentType.includes("application/json")) {
+    console.error("  Server returned unexpected response. Is the Honeytree web app running?");
+    return false;
+  }
+  const { device_code, user_code, interval } = await res.json();
+
+  console.log();
+  console.log(`  Your code: ${user_code}`);
+  console.log();
+  console.log("  Enter this code on your Honeytree dashboard to link your terminal.");
+  console.log("  Waiting...");
+
+  while (true) {
+    await new Promise((r) => setTimeout(r, (interval || 5) * 1000));
+
+    try {
+      const pollRes = await fetch(`${apiUrl}/api/auth/device/poll`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code }),
+      });
+
+      const pollContentType = pollRes.headers.get("content-type") || "";
+      if (!pollContentType.includes("application/json")) continue;
+
+      if (!pollRes.ok) {
+        if (pollRes.status === 410) {
+          console.error("  Code expired. Run honeytree login again.");
+          return false;
+        }
+        continue;
+      }
+
+      const data = await pollRes.json();
+
+      if (data.status === "complete") {
+        saveAuth({
+          access_token: data.access_token,
+          user_id: data.user.id,
+          username: data.user.username,
+        });
+        console.log(`  Linked as ${data.user.username}`);
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+}

package/src/components/ForestApp.js

@@ -0,0 +1,404 @@
+import React, { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import { getAuth, isLoggedIn } from "../auth.js";
+import { getRewards, syncRewards, uncelebratedUnlocked, markCelebrated } from "../rewards.js";
+import UnlockCelebration from "./UnlockCelebration.js";
+
+import ForestScene from "./ForestScene.js";
+import StatsBar from "./StatsBar.js";
+import TreeInfoPopup from "./TreeInfoPopup.js";
+
+import { getForestFile, readForest, writeForest } from "../state.js";
+import { migrateLayout } from "../migrate.js";
+import { getVirtualWidth } from "../plant.js";
+import { getAnimationFrames } from "../animation.js";
+import { createForestWatcher } from "../viewer2d.js";
+import { readActiveSession, isStale } from "../session.js";
+import { readNewTokens } from "../transcript.js";
+import { tokensToTree } from "../growth.js";
+import LiveTree from "./LiveTree.js";
+
+const h = React.createElement;
+const PAN_STEP = 4;
+
+export default function ForestApp() {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+
+  const forestFile = getForestFile();
+
+  const [forest, setForest] = useState(() => {
+    const f = readForest();
+    if (!f || !fs.existsSync(forestFile)) {
+      console.error('No forest found. Run "honeytree init" first.');
+      process.exit(1);
+    }
+    if (f && (!f.layoutVersion || f.layoutVersion < 2)) {
+      const termWidth = stdout?.columns || 80;
+      migrateLayout(f, termWidth);
+    }
+    return f;
+  });
+
+  const [viewportX, setViewportX] = useState(forest.viewportX || 0);
+  const [windTick, setWindTick] = useState(0);
+  const [termWidth, setTermWidth] = useState(stdout?.columns || 80);
+  const [selectedTreeIdx, setSelectedTreeIdx] = useState(-1);
+  const [showPopup, setShowPopup] = useState(false);
+  const [animating, setAnimating] = useState(false);
+  const [spriteOverride, setSpriteOverride] = useState(null);
+  const [groundOverlay, setGroundOverlay] = useState(null);
+  const [groundPulse, setGroundPulse] = useState(false);
+  const [milestonePrompt, setMilestonePrompt] = useState(null);
+  const [rewards, setRewards] = useState(() => getRewards());
+  const [celebrationQueue, setCelebrationQueue] = useState(() => uncelebratedUnlocked());
+
+  const [activeTree, setActiveTree] = useState(null);
+  const [liveTokens, setLiveTokens] = useState(0);
+  const tailRef = useRef({ path: null, offset: 0, tokens: 0, startedAt: 0 });
+
+  const ignoreNextChange = useRef(false);
+  const lastMaxId = useRef(forest.trees.reduce((max, t) => Math.max(max, t.id), 0));
+  const lastTotalPrompts = useRef(forest.totalPrompts);
+  const forestRef = useRef(forest);
+  forestRef.current = forest;
+  const viewportXRef = useRef(viewportX);
+  viewportXRef.current = viewportX;
+
+  // Fetch rewards from server (async, non-blocking)
+  useEffect(() => {
+    if (isLoggedIn()) {
+      syncRewards().then((r) => {
+        if (r) {
+          setRewards(r);
+          setCelebrationQueue(uncelebratedUnlocked());
+        }
+      }).catch(() => {});
+    }
+  }, []);
+
+  // Sync width to disk
+  const syncWidth = useCallback(() => {
+    const cols = stdout?.columns || 80;
+    const f = forestRef.current;
+    if (f.viewerWidth !== cols) {
+      f.viewerWidth = cols;
+      ignoreNextChange.current = true;
+      writeForest(f);
+    }
+  }, [stdout]);
+
+  useEffect(() => {
+    syncWidth();
+  }, [syncWidth]);
+
+  // Clamp viewport helper
+  const clampViewport = useCallback((x) => {
+    const vw = getVirtualWidth(forestRef.current.trees.length, termWidth);
+    return Math.max(0, Math.min(x, Math.max(0, vw - termWidth)));
+  }, [termWidth]);
+
+  // Get visible trees in viewport for selection
+  const getVisibleTrees = useCallback(() => {
+    const vpEnd = viewportX + termWidth;
+    return forest.trees
+      .filter((t) => t.x >= viewportX && t.x < vpEnd)
+      .sort((a, b) => a.x - b.x);
+  }, [forest, viewportX, termWidth]);
+
+  // Wind interval
+  useEffect(() => {
+    const id = setInterval(() => {
+      if (!animating) {
+        setWindTick((t) => t + 1);
+      }
+    }, 2500);
+    return () => clearInterval(id);
+  }, [animating]);
+
+  // Live growth: tail the active Claude Code session transcript.
+  useEffect(() => {
+    const id = setInterval(() => {
+      const s = readActiveSession();
+      if (!s || isStale(s)) {
+        if (tailRef.current.path) {
+          tailRef.current = { path: null, offset: 0, tokens: 0, startedAt: 0 };
+          setActiveTree(null);
+          setLiveTokens(0);
+        }
+        return;
+      }
+      if (tailRef.current.path !== s.transcript_path || tailRef.current.startedAt !== s.turnStartedAt) {
+        tailRef.current = {
+          path: s.transcript_path,
+          offset: s.baselineOffset || 0,
+          tokens: 0,
+          startedAt: s.turnStartedAt,
+        };
+      }
+      const { tokens, newOffset } = readNewTokens(tailRef.current.path, tailRef.current.offset);
+      tailRef.current.offset = newOffset;
+      tailRef.current.tokens += tokens;
+      const shape = tokensToTree(tailRef.current.tokens);
+      setLiveTokens(tailRef.current.tokens);
+      setActiveTree({
+        id: -1,
+        type: s.type || "oak",
+        x: typeof s.x === "number" ? s.x : 0,
+        growth: shape.growth,
+        heightBonus: shape.heightBonus,
+        variant: s.variant ?? null,
+        plantedAt: new Date().toISOString(),
+      });
+    }, 1000);
+    return () => clearInterval(id);
+  }, []);
+
+  // Resize handler
+  useEffect(() => {
+    const onResize = () => {
+      const cols = stdout?.columns || 80;
+      setTermWidth(cols);
+      syncWidth();
+    };
+    stdout?.on("resize", onResize);
+    return () => stdout?.off("resize", onResize);
+  }, [stdout, syncWidth]);
+
+  // Animate new tree
+  const animateNewTree = useCallback(async (updatedForest, newTreeId) => {
+    const tree = updatedForest.trees.find((t) => t.id === newTreeId);
+    if (!tree) return;
+
+    const FRAME_COUNT = 40;
+    const FRAME_DELAY = 125;
+
+    const frames = getAnimationFrames(tree.type, tree.growth, FRAME_COUNT);
+
+    for (let i = 0; i < frames.length; i++) {
+      const frameData = frames[i];
+      setSpriteOverride({ treeId: tree.id, sprite: frameData.sprite });
+      setGroundPulse(frameData.groundPulse ?? false);
+      if (frameData.groundOverlay) {
+        setGroundOverlay({ treeX: tree.x, overlays: frameData.groundOverlay });
+      } else {
+        setGroundOverlay(null);
+      }
+      setWindTick(i);
+      await new Promise((r) => setTimeout(r, FRAME_DELAY));
+    }
+
+    setSpriteOverride(null);
+    setGroundOverlay(null);
+    setGroundPulse(false);
+  }, []);
+
+  // File watcher + polling for forest changes
+  useEffect(() => {
+    const checkForUpdates = async () => {
+      if (animating) return;
+      if (ignoreNextChange.current) {
+        ignoreNextChange.current = false;
+        return;
+      }
+      const updated = readForest();
+      if (!updated) return;
+      if (updated.totalPrompts === lastTotalPrompts.current) return;
+
+      const nextMaxId = updated.trees.reduce((max, t) => Math.max(max, t.id), 0);
+      lastTotalPrompts.current = updated.totalPrompts;
+      setForest(updated);
+      forestRef.current = updated;
+      setActiveTree(null);
+      setLiveTokens(0);
+      tailRef.current = { path: null, offset: 0, tokens: 0, startedAt: 0 };
+
+      // Check for milestone flag
+      try {
+        const milestoneFile = path.join(os.homedir(), ".honeydew", "milestone.json");
+        if (fs.existsSync(milestoneFile)) {
+          const milestone = JSON.parse(fs.readFileSync(milestoneFile, "utf8"));
+          setMilestonePrompt(milestone);
+        }
+      } catch {}
+
+      if (nextMaxId > lastMaxId.current) {
+        lastMaxId.current = nextMaxId;
+        const newTree = updated.trees.find((t) => t.id === nextMaxId);
+        if (newTree) {
+          const tw = stdout?.columns || 80;
+          const vw = getVirtualWidth(updated.trees.length, tw);
+          const newVpx = Math.max(0, Math.min(newTree.x - Math.floor(tw / 2), Math.max(0, vw - tw)));
+          setViewportX(newVpx);
+        }
+        setAnimating(true);
+        await animateNewTree(updated, nextMaxId);
+        setAnimating(false);
+      }
+    };
+
+    const watcher = createForestWatcher(forestFile, () => checkForUpdates());
+
+    let lastMtime = 0;
+    try { lastMtime = fs.statSync(forestFile).mtimeMs; } catch {}
+
+    const pollId = setInterval(() => {
+      try {
+        const mtime = fs.statSync(forestFile).mtimeMs;
+        if (mtime !== lastMtime) {
+          lastMtime = mtime;
+          checkForUpdates();
+        }
+      } catch {}
+    }, 800);
+
+    return () => {
+      if (watcher) try { watcher.close(); } catch {}
+      clearInterval(pollId);
+    };
+  }, [forestFile, animating, animateNewTree, stdout]);
+
+  // Save viewport on unmount
+  useEffect(() => {
+    return () => {
+      const f = forestRef.current;
+      f.viewportX = viewportXRef.current;
+      ignoreNextChange.current = true;
+      writeForest(f);
+    };
+  }, []);
+
+  // Keyboard input
+  useInput((input, key) => {
+    if (celebrationQueue.length > 0) return;
+
+    if (milestonePrompt) {
+      const milestoneFile = path.join(os.homedir(), ".honeydew", "milestone.json");
+      if (input === "y") {
+        // Open checkout in browser
+        const auth = getAuth();
+        if (auth && auth.access_token) {
+          fetch("https://tryhoney.xyz/api/checkout", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${auth.access_token}`,
+            },
+          })
+            .then((r) => r.json())
+            .then(({ url }) => {
+              if (url) {
+                try { execSync(`open "${url}"`); } catch {
+                  try { execSync(`xdg-open "${url}"`); } catch {}
+                }
+              }
+            })
+            .catch(() => {});
+        }
+        try { fs.unlinkSync(milestoneFile); } catch {}
+        setMilestonePrompt(null);
+      } else if (input === "n") {
+        try { fs.unlinkSync(milestoneFile); } catch {}
+        setMilestonePrompt(null);
+      }
+      return;
+    }
+
+    if (showPopup) {
+      if (key.escape) {
+        setShowPopup(false);
+      }
+      return;
+    }
+
+    if (input === "q") {
+      const f = forestRef.current;
+      f.viewportX = viewportXRef.current;
+      ignoreNextChange.current = true;
+      writeForest(f);
+      exit();
+      return;
+    }
+
+    if (key.leftArrow) {
+      setViewportX((x) => clampViewport(x - PAN_STEP));
+      return;
+    }
+    if (key.rightArrow) {
+      setViewportX((x) => clampViewport(x + PAN_STEP));
+      return;
+    }
+
+    if (key.upArrow) {
+      const visible = getVisibleTrees();
+      if (visible.length === 0) return;
+      setSelectedTreeIdx((prev) => {
+        if (prev <= 0) return visible.length - 1;
+        return prev - 1;
+      });
+      return;
+    }
+    if (key.downArrow || key.tab) {
+      const visible = getVisibleTrees();
+      if (visible.length === 0) return;
+      setSelectedTreeIdx((prev) => {
+        if (prev < 0 || prev >= visible.length - 1) return 0;
+        return prev + 1;
+      });
+      return;
+    }
+
+    if (key.return) {
+      const visible = getVisibleTrees();
+      if (selectedTreeIdx >= 0 && selectedTreeIdx < visible.length) {
+        setShowPopup(true);
+      }
+      return;
+    }
+  });
+
+  const visibleTrees = getVisibleTrees();
+  const selectedTree = selectedTreeIdx >= 0 && selectedTreeIdx < visibleTrees.length
+    ? visibleTrees[selectedTreeIdx]
+    : null;
+
+  const liveForest = activeTree
+    ? { ...forest, trees: [...forest.trees, activeTree] }
+    : forest;
+
+  if (celebrationQueue.length > 0) {
+    const current = celebrationQueue[0];
+    return h(UnlockCelebration, {
+      varietyKey: current,
+      onDismiss: () => {
+        markCelebrated(current);
+        setCelebrationQueue((q) => q.slice(1));
+      },
+    });
+  }
+
+  return h(Box, { flexDirection: "column" },
+    h(ForestScene, {
+      forest: liveForest,
+      viewportX,
+      windTick,
+      termWidth,
+      spriteOverride,
+      groundOverlay,
+      groundPulse,
+      rewards,
+    }),
+    h(StatsBar, { forest, viewportX, termWidth, rewards }),
+    activeTree ? h(LiveTree, { tokens: liveTokens }) : null,
+    showPopup && selectedTree ? h(TreeInfoPopup, { tree: selectedTree }) : null,
+    milestonePrompt ? h(Box, { flexDirection: "column", paddingX: 1 },
+      h(Text, { color: "green", bold: true },
+        `${milestonePrompt.totalPrompts} virtual trees! You've unlocked a real tree planting ($1). Plant one? (y/n)`
+      ),
+    ) : null,
+  );
+}

package/src/components/ForestScene.js

@@ -0,0 +1,26 @@
+import React, { useMemo } from "react";
+import { Text } from "ink";
+
+import { renderFrame } from "../renderer.js";
+import { getVirtualWidth } from "../plant.js";
+
+const h = React.createElement;
+
+export default function ForestScene({ forest, viewportX, windTick, termWidth, spriteOverride, groundOverlay, groundPulse, rewards }) {
+  const frame = useMemo(() => {
+    const vw = getVirtualWidth(forest.trees.length, termWidth);
+    return renderFrame(forest, termWidth, {
+      twinkleSeed: windTick,
+      viewportX,
+      virtualWidth: vw,
+      windTick,
+      includeStats: false,
+      spriteOverride: spriteOverride ?? undefined,
+      groundOverlay: groundOverlay ?? undefined,
+      groundPulse: groundPulse ?? false,
+      rewards: rewards ?? undefined,
+    });
+  }, [forest, viewportX, windTick, termWidth, spriteOverride, groundOverlay, groundPulse, rewards]);
+
+  return h(Text, null, frame);
+}

package/src/components/LiveTree.js

@@ -0,0 +1,14 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+const h = React.createElement;
+
+// Small status line shown while a live turn is streaming.
+export default function LiveTree({ tokens }) {
+  return h(
+    Box,
+    {},
+    h(Text, { color: "green" }, "● live "),
+    h(Text, { color: "yellow" }, `· ${tokens.toLocaleString()} tok`),
+  );
+}